spotterm 0.3.0

//! TUI display calculations (pure functions) and the Now Playing snapshot. Independent of
//! ratatui: progress interpolation and ratio computation take/return primitives so they are unit
//! testable (rendering is on the `mod.rs` side).

use std::time::Instant;

use crate::format::{display_width, format_ms, truncate};
use crate::theme;

/// A snapshot of the playback status from the most recent poll. Using `fetched_at` as the base,
/// progress between polls is interpolated locally to look smooth.
pub struct NowPlaying {
    pub is_playing: bool,
    pub title: String,
    pub artists: String,
    pub album: Option<String>,
    pub progress_ms: u128,
    pub duration_ms: u128,
    pub device: String,
    pub volume: Option<u8>,
    /// The current track's URI (`spotify:track:…`). Used for the save action and track-change detection.
    /// `None` for episodes or when track info is unknown.
    pub track_uri: Option<String>,
    /// The (already selected) cover-art image URL. Used for art fetching and track-change detection. `None` if absent.
    pub album_image_url: Option<String>,
    /// The time this snapshot was fetched (the base for progress interpolation).
    pub fetched_at: Instant,
}

/// If playing, return the progress advanced from the base `base_ms` by the elapsed time (capped at
/// `duration_ms`). While paused, stays at the base. When `duration_ms == 0` (unknown length), no cap.
pub fn interpolate_progress(
    base_ms: u128,
    elapsed_ms: u128,
    duration_ms: u128,
    playing: bool,
) -> u128 {
    if !playing {
        return base_ms;
    }
    let advanced = base_ms.saturating_add(elapsed_ms);
    if duration_ms == 0 {
        advanced
    } else {
        advanced.min(duration_ms)
    }
}

/// Return the progress ratio 0.0..=1.0. When `duration_ms == 0`, returns 0.0.
pub fn progress_ratio(progress_ms: u128, duration_ms: u128) -> f64 {
    if duration_ms == 0 {
        return 0.0;
    }
    (progress_ms as f64 / duration_ms as f64).clamp(0.0, 1.0)
}

/// The lines needed for rendering (primitive strings + progress ratio). Kept independent of
/// ratatui so the render logic is a pure function and unit testable (`mod.rs::draw` just feeds
/// these into widgets).
pub struct RenderLines {
    pub state: String,
    pub title: String,
    pub artist: String,
    pub album: String,
    pub ratio: f64,
    pub progress_label: String,
    pub device: String,
}

/// A short marker for the current track's saved state (appended to the end of the state line).
/// `None` means the state is unknown and nothing is shown.
fn saved_marker(saved: Option<bool>) -> String {
    match saved {
        Some(true) => format!("   {} Saved", theme::HEART),
        Some(false) => format!("   {} Not saved", theme::HEART_O),
        None => String::new(),
    }
}

/// Build the Now Playing display lines. `elapsed_ms` is the time since the last fetch (the base for
/// progress interpolation), `width` is the wrap width per line, and `saved` is the current track's
/// library saved state (`None` if unknown). When nothing is playing (`None`), returns a hint message.
pub fn render_lines(
    now: Option<&NowPlaying>,
    elapsed_ms: u128,
    width: usize,
    saved: Option<bool>,
) -> RenderLines {
    let line = |label: &str, value: &str| -> String {
        format!(
            "{label}{}",
            truncate(value, width.saturating_sub(display_width(label)))
        )
    };

    let Some(n) = now else {
        return RenderLines {
            state: "Nothing is playing".to_string(),
            title: "  (press p to resume / `spotterm play` to start)".to_string(),
            artist: String::new(),
            album: String::new(),
            ratio: 0.0,
            progress_label: "-".to_string(),
            device: String::new(),
        };
    };

    let prog = interpolate_progress(n.progress_ms, elapsed_ms, n.duration_ms, n.is_playing);
    let head = if n.is_playing {
        format!("{} Playing", theme::PLAY)
    } else {
        format!("{} Paused", theme::PAUSE)
    };
    let vol = n
        .volume
        .map(|v| format!("{v}%"))
        .unwrap_or_else(|| "-".to_string());

    RenderLines {
        state: format!("{head}{}", saved_marker(saved)),
        title: line(&format!("{} ", theme::MUSIC), &n.title),
        artist: line(&format!("{} ", theme::ARTIST), &n.artists),
        album: n
            .album
            .as_deref()
            .map(|a| line(&format!("{} ", theme::ALBUM), a))
            .unwrap_or_default(),
        ratio: progress_ratio(prog, n.duration_ms),
        progress_label: format!("{} / {}", format_ms(prog), format_ms(n.duration_ms)),
        device: format!("{} {} (vol {vol})", theme::VOLUME, n.device),
    }
}

/// Pure function returning the target position (ms) after a seek. Adds `delta_ms` (negative to
/// rewind) to `current_ms` and clamps to `[0, duration_ms]`. When `duration_ms == 0` (unknown
/// length), there is no upper bound.
pub fn seek_target(current_ms: u128, duration_ms: u128, delta_ms: i64) -> u128 {
    let target = if delta_ms >= 0 {
        current_ms.saturating_add(delta_ms as u128)
    } else {
        current_ms.saturating_sub(delta_ms.unsigned_abs() as u128)
    };
    if duration_ms == 0 {
        target
    } else {
        target.min(duration_ms)
    }
}

/// The supplementary line of the search overlay (the default hint when there is no `message`).
/// Varies by phase and result count.
pub fn search_hint(is_input: bool, results_len: usize) -> String {
    if is_input {
        "Enter to search / Esc to go back".to_string()
    } else {
        format!("{results_len} results — ↑↓ select / Enter play / Esc edit query")
    }
}

/// Format one search-result row (`name — artists`, truncated to the width). Selection highlighting
/// is done by the caller. Truncates at a width reduced by the 2 columns of the selection marker `"▶ "`.
pub fn search_row(name: &str, artists: &str, width: usize) -> String {
    let text = if artists.is_empty() {
        name.to_string()
    } else {
        format!("{name} — {artists}")
    };
    truncate(&text, width.saturating_sub(2))
}

/// Pure function that formats one device row for the device picker.
/// Active is shown with `● (active)`, inactive with `○`, and restricted is annotated.
/// Truncates at a width reduced by the 2 columns of the selection marker `"▶ "`.
pub fn device_row(
    name: &str,
    type_label: &str,
    vol: Option<u32>,
    is_active: bool,
    is_restricted: bool,
    width: usize,
) -> String {
    let mark = if is_active { "●" } else { "○" };
    let vol_s = match vol {
        Some(v) => format!("vol {v}%"),
        None => "vol -".to_string(),
    };
    let mut text = format!("{mark} {name} [{type_label}]  {vol_s}");
    if is_active {
        text.push_str("  (active)");
    }
    if is_restricted {
        text.push_str(" (restricted)");
    }
    truncate(&text, width.saturating_sub(2))
}

/// The list of key bindings (key, description). The single source of truth for the footer and the
/// help overlay (both reference this to prevent notation drift).
pub fn help_entries() -> &'static [(&'static str, &'static str)] {
    &[
        ("space", "play / pause"),
        ("n / p", "next / previous track"),
        ("← / →", "seek 5s (back / forward)"),
        ("+ / -", "volume ±5"),
        ("s", "save / unsave the current track"),
        ("/", "search and play"),
        ("2", "browse library"),
        ("d", "select device"),
        ("r", "refresh (resume auto-refresh)"),
        ("?", "this help"),
        ("q / Esc", "quit"),
        ("Ctrl-C", "quit (from any screen)"),
    ]
}

/// The kind of a status line. Used to decide coloring.
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum StatusKind {
    Warn,
    Ok,
    Info,
}

/// Pure function that classifies a status string by kind. Starting with the warning glyph is a
/// warning, starting with a success glyph is Ok, and anything else is Info (startup, hints, etc.).
/// The glyphs come from [`theme`] so the classifier stays in sync with the strings the app emits.
pub fn status_kind(s: &str) -> StatusKind {
    let trimmed = s.trim_start();
    if trimmed.starts_with(theme::WARN) {
        StatusKind::Warn
    } else if theme::OK_PREFIXES.iter().any(|p| trimmed.starts_with(p)) {
        StatusKind::Ok
    } else {
        StatusKind::Info
    }
}

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

    #[test]
    fn interpolate_advances_only_while_playing() {
        // While playing, advances by the elapsed time
        assert_eq!(interpolate_progress(10_000, 3_000, 200_000, true), 13_000);
        // While paused, stays at the base
        assert_eq!(interpolate_progress(10_000, 3_000, 200_000, false), 10_000);
    }

    #[test]
    fn interpolate_clamps_to_duration() {
        // Does not exceed the length
        assert_eq!(
            interpolate_progress(195_000, 10_000, 200_000, true),
            200_000
        );
        // Unknown length (0) is not capped
        assert_eq!(interpolate_progress(195_000, 10_000, 0, true), 205_000);
    }

    #[test]
    fn progress_ratio_bounds() {
        assert_eq!(progress_ratio(0, 200_000), 0.0);
        assert_eq!(progress_ratio(100_000, 200_000), 0.5);
        assert_eq!(progress_ratio(200_000, 200_000), 1.0);
        // Length 0 is 0.0 (avoids division by zero)
        assert_eq!(progress_ratio(50_000, 0), 0.0);
        // Even if progress > duration, clamp to 1.0
        assert_eq!(progress_ratio(250_000, 200_000), 1.0);
    }

    fn sample(is_playing: bool) -> NowPlaying {
        NowPlaying {
            is_playing,
            title: "Song".to_string(),
            artists: "Artist".to_string(),
            album: Some("Album".to_string()),
            progress_ms: 60_000,
            duration_ms: 180_000,
            device: "MacBook Pro".to_string(),
            volume: Some(40),
            track_uri: Some("spotify:track:xxxx".to_string()),
            album_image_url: None,
            fetched_at: std::time::Instant::now(),
        }
    }

    #[test]
    fn render_lines_shows_track_and_progress() {
        let n = sample(true);
        let out = render_lines(Some(&n), 0, 80, None);
        assert_eq!(out.state, format!("{} Playing", theme::PLAY));
        assert!(out.title.contains("Song"));
        assert!(out.artist.contains("Artist"));
        assert_eq!(out.progress_label, "1:00 / 3:00");
        assert_eq!(out.ratio, 60_000.0 / 180_000.0);
        assert!(out.device.contains("MacBook Pro"));
        assert!(out.device.contains("40%"));
    }

    #[test]
    fn render_lines_prefixes_info_lines_with_icons() {
        let n = sample(true);
        let out = render_lines(Some(&n), 0, 80, None);
        assert!(
            out.title.starts_with(theme::MUSIC),
            "title needs music icon"
        );
        assert!(
            out.artist.starts_with(theme::ARTIST),
            "artist needs artist icon"
        );
        assert!(
            out.album.starts_with(theme::ALBUM),
            "album needs album icon"
        );
        assert!(
            out.device.starts_with(theme::VOLUME),
            "device needs volume icon"
        );
    }

    #[test]
    fn render_lines_empty_state_when_nothing_playing() {
        let out = render_lines(None, 0, 80, None);
        assert_eq!(out.state, "Nothing is playing");
        assert!(out.artist.is_empty());
        assert_eq!(out.ratio, 0.0);
    }

    #[test]
    fn render_lines_shows_saved_marker() {
        let n = sample(true);
        // Saved shows the filled heart, not-saved the empty heart, unknown shows neither.
        assert!(
            render_lines(Some(&n), 0, 80, Some(true))
                .state
                .contains(theme::HEART)
        );
        assert!(
            render_lines(Some(&n), 0, 80, Some(false))
                .state
                .contains(theme::HEART_O)
        );
        let unknown = render_lines(Some(&n), 0, 80, None).state;
        assert!(!unknown.contains(theme::HEART) && !unknown.contains(theme::HEART_O));
    }

    #[test]
    fn seek_target_advances_and_rewinds() {
        // Forward
        assert_eq!(seek_target(60_000, 180_000, 5_000), 65_000);
        // Backward
        assert_eq!(seek_target(60_000, 180_000, -5_000), 55_000);
    }

    #[test]
    fn seek_target_clamps_bounds() {
        // Lower bound 0 (rewound too far)
        assert_eq!(seek_target(3_000, 180_000, -5_000), 0);
        // Upper bound duration (advanced too far)
        assert_eq!(seek_target(178_000, 180_000, 5_000), 180_000);
        // Unknown length (0) has no upper bound
        assert_eq!(seek_target(178_000, 0, 5_000), 183_000);
    }

    #[test]
    fn search_row_joins_name_and_artists() {
        assert_eq!(search_row("Song", "Artist", 80), "Song — Artist");
        // With no artist, just the track name
        assert_eq!(search_row("Song", "", 80), "Song");
    }

    #[test]
    fn search_row_truncates_with_symbol_margin() {
        // width 10 → truncate to 8 chars after subtracting the 2 columns of the marker (ends with …)
        let out = search_row("abcdefghij", "", 10);
        assert_eq!(out.chars().count(), 8);
        assert!(out.ends_with('…'));
    }

    #[test]
    fn search_hint_varies_by_phase() {
        assert!(search_hint(true, 0).contains("Enter to search"));
        let results = search_hint(false, 3);
        assert!(results.starts_with("3 results"));
        assert!(results.contains("Enter play"));
    }

    #[test]
    fn device_row_active_marks_and_notes() {
        let out = device_row("MacBook Pro", "Computer", Some(65), true, false, 80);
        assert!(out.starts_with("● MacBook Pro [Computer]"));
        assert!(out.contains("vol 65%"));
        assert!(out.contains("(active)"));
    }

    #[test]
    fn device_row_inactive_without_volume() {
        let out = device_row("Speaker", "Speaker", None, false, false, 80);
        assert!(out.starts_with("○ Speaker [Speaker]"));
        assert!(out.contains("vol -"));
        assert!(!out.contains("(active)"));
    }

    #[test]
    fn device_row_restricted_is_annotated() {
        let out = device_row("TV", "Tv", Some(40), false, true, 80);
        assert!(out.starts_with("○ TV [Tv]"));
        assert!(out.contains("(restricted)"));
    }

    #[test]
    fn device_row_truncates_with_symbol_margin() {
        // width 10 → truncate to 8 columns after subtracting the 2 columns of the marker
        let out = device_row("abcdefghij", "X", None, false, false, 10);
        assert!(crate::format::display_width(&out) <= 8);
        assert!(out.ends_with('…'));
    }

    #[test]
    fn help_entries_cover_all_keys() {
        let keys: Vec<&str> = help_entries().iter().map(|(k, _)| *k).collect();
        for k in [
            "space",
            "n / p",
            "← / →",
            "+ / -",
            "s",
            "/",
            "2",
            "d",
            "r",
            "?",
            "q / Esc",
        ] {
            assert!(keys.contains(&k), "help is missing {k}");
        }
        // Descriptions are non-empty
        assert!(help_entries().iter().all(|(_, desc)| !desc.is_empty()));
    }

    #[test]
    fn status_kind_classifies() {
        assert_eq!(
            status_kind(&format!("{} refresh failed: x", theme::WARN)),
            StatusKind::Warn
        );
        assert_eq!(
            status_kind(&format!("{} play", theme::PLAY)),
            StatusKind::Ok
        );
        assert_eq!(
            status_kind(&format!("{} saved to your library", theme::HEART)),
            StatusKind::Ok
        );
        assert_eq!(
            status_kind(&format!("{} seek 1:23", theme::SEEK)),
            StatusKind::Ok
        );
        assert_eq!(status_kind("starting…"), StatusKind::Info);
    }

    #[test]
    fn status_kind_recognizes_every_theme_prefix() {
        // Guards the theme<->classifier contract: every glyph the app prefixes an "ok" status with
        // (declared in theme::OK_PREFIXES) must classify as Ok, and the warning glyph as Warn. This
        // catches drift where a status line is emitted with a glyph the classifier no longer matches.
        for icon in theme::OK_PREFIXES {
            assert_eq!(
                status_kind(&format!("{icon} action done")),
                StatusKind::Ok,
                "ok prefix {icon:?} must classify as Ok"
            );
        }
        assert_eq!(
            status_kind(&format!("{} boom", theme::WARN)),
            StatusKind::Warn
        );
    }
}