Added Visual select for multiple tracks, added Queue management. Added info for tracks

src/ui/popup.rs

@@ -1,9 +1,10 @@
 use ratatui::Frame;
 use ratatui::layout::{Alignment, Constraint, Flex, Layout, Rect};
 use ratatui::text::{Line, Span};
-use ratatui::widgets::{Block, Clear, Paragraph};
+use ratatui::widgets::{Block, Clear, Paragraph, Wrap};
 
 use super::theme;
+use crate::api::models::{ArtistRef, TrackItem};
 use crate::app::state::{AppState, Loadable, Popup, addable_playlists};
 
 pub fn draw(frame: &mut Frame, state: &AppState) {
@@ -13,6 +14,11 @@ pub fn draw(frame: &mut Frame, state: &AppState) {
         }
         Some(Popup::NewPlaylist { input, busy, .. }) => draw_name_entry(frame, input, *busy),
         Some(Popup::Devices { cursor }) => draw_devices(frame, state, *cursor),
+        Some(Popup::TrackInfo {
+            tracks,
+            cursor,
+            scroll,
+        }) => draw_track_info(frame, tracks, *cursor, *scroll),
         Some(Popup::LogDetail(entry)) => draw_log_detail(frame, entry),
         None => {}
     }
@@ -137,6 +143,152 @@ fn draw_log_detail(frame: &mut Frame, entry: &crate::config::logging::LogEntry)
     );
 }
 
+fn draw_track_info(frame: &mut Frame, tracks: &[TrackItem], cursor: usize, scroll: usize) {
+    let Some(track) = tracks.get(cursor.min(tracks.len().saturating_sub(1))) else {
+        return;
+    };
+    let width = 92.min(frame.area().width.saturating_sub(4)).max(48);
+    let height = 24.min(frame.area().height.saturating_sub(2)).max(10);
+    let area = centered(frame.area(), width, height);
+    let title = if tracks.len() > 1 {
+        format!(" Track info — {}/{} ", cursor + 1, tracks.len())
+    } else {
+        " Track info ".to_string()
+    };
+
+    let block = Block::bordered()
+        .title(title)
+        .title_style(theme::header())
+        .border_style(theme::accent());
+    let inner = block.inner(area);
+    frame.render_widget(Clear, area);
+    frame.render_widget(block, area);
+
+    let [body, footer] = Layout::vertical([Constraint::Min(1), Constraint::Length(1)]).areas(inner);
+    let lines = track_info_lines(track);
+    let max_scroll = lines.len().saturating_sub(usize::from(body.height));
+    frame.render_widget(
+        Paragraph::new(lines)
+            .wrap(Wrap { trim: false })
+            .scroll((scroll.min(max_scroll) as u16, 0)),
+        body,
+    );
+
+    let hint = if tracks.len() > 1 {
+        "j/k scroll · h/left previous · l/right next · esc close"
+    } else {
+        "j/k scroll · esc close"
+    };
+    frame.render_widget(
+        Paragraph::new(Line::styled(hint, theme::dim())).alignment(Alignment::Center),
+        footer,
+    );
+}
+
+fn track_info_lines(track: &TrackItem) -> Vec<Line<'static>> {
+    vec![
+        field("ID", track.id.to_string()),
+        field("Title", track.title.clone()),
+        field("Artists", artist_refs(&track.artists)),
+        field("Featured artists", artist_refs(&track.featured_artists)),
+        field("Release", release_label(track)),
+        field("Release ID", track.release_id.to_string()),
+        field("Disc", opt_display(track.disc_number)),
+        field("Track number", opt_display(track.track_number)),
+        field(
+            "Duration",
+            format!(
+                "{} ({:.2}s)",
+                track.duration_label(),
+                track.duration_seconds
+            ),
+        ),
+        field("Uploader", empty_dash(&track.uploader_name)),
+        field("Audio format", opt_string(track.audio_format.clone())),
+        field(
+            "Bitrate",
+            opt_map(track.audio_bitrate, |v| format!("{v} kbps")),
+        ),
+        field(
+            "Sample rate",
+            opt_map(track.audio_sample_rate, |v| {
+                format!("{:.1} kHz", f64::from(v) / 1000.0)
+            }),
+        ),
+        field(
+            "Bit depth",
+            opt_map(track.audio_bit_depth, |v| format!("{v} bit")),
+        ),
+        field("File size", file_size(track.file_size_bytes)),
+        field("Last.fm listeners", opt_display(track.lastfm_listeners)),
+        field("Last.fm plays", opt_display(track.lastfm_playcount)),
+        field(
+            "Last.fm rating",
+            opt_map(track.lastfm_rating, |v| format!("{v:.3}")),
+        ),
+        field(
+            "Last.fm updated",
+            opt_string(track.lastfm_updated_at.clone()),
+        ),
+        field("Stream URL", empty_dash(&track.stream_url)),
+        field("Cover URL", opt_string(track.cover_url.clone())),
+    ]
+}
+
+fn field(label: &'static str, value: String) -> Line<'static> {
+    Line::from(vec![
+        Span::styled(format!("{label:<18}"), theme::dim()),
+        Span::raw(value),
+    ])
+}
+
+fn artist_refs(items: &[ArtistRef]) -> String {
+    if items.is_empty() {
+        return "—".to_string();
+    }
+    items
+        .iter()
+        .map(|artist| format!("{} ({})", artist.name, artist.id))
+        .collect::<Vec<_>>()
+        .join(", ")
+}
+
+fn release_label(track: &TrackItem) -> String {
+    let mut label = empty_dash(&track.release_title);
+    if let Some(year) = track.release_year {
+        label.push_str(&format!(" ({year})"));
+    }
+    label
+}
+
+fn empty_dash(value: &str) -> String {
+    if value.trim().is_empty() {
+        "—".to_string()
+    } else {
+        value.to_string()
+    }
+}
+
+fn opt_string(value: Option<String>) -> String {
+    value
+        .filter(|value| !value.trim().is_empty())
+        .unwrap_or_else(|| "—".to_string())
+}
+
+fn opt_display<T: std::fmt::Display>(value: Option<T>) -> String {
+    opt_map(value, |value| value.to_string())
+}
+
+fn opt_map<T>(value: Option<T>, format: impl FnOnce(T) -> String) -> String {
+    value.map(format).unwrap_or_else(|| "—".to_string())
+}
+
+fn file_size(value: Option<i64>) -> String {
+    value
+        .map(|bytes| format!("{:.1} MB ({} bytes)", bytes as f64 / 1_048_576.0, bytes))
+        .unwrap_or_else(|| "—".to_string())
+}
+
 fn draw_picker(frame: &mut Frame, state: &AppState, track_title: &str, cursor: usize) {
     let options = addable_playlists(state);
     let loading = !matches!(&state.playlists.list, Some(Loadable::Ready(_)));