Merge pull request 'autocompletion' (#1) from autocompletion into main

Reviewed-on: https://codeberg.org/salmonik/RSPlayer/pulls/1

5 files changed, 542 insertions, 136 deletions

diff --git a/src/cli.rs b/src/cli.rs
index f5fdd2c..e4bb484 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -92,6 +92,13 @@ pub enum Commands {
         #[arg(value_name = "SHELL")]
         shell: Option<String>,
     },
+    #[clap(hide = true)]
+    /// Complete artists, albums, or tracks from database
+    DbComplete {
+        /// Query string (e.g. \"J\", \"Artist/\", \"Artist/Album/\")
+        #[arg(value_name = "QUERY")]
+        query: String,
+    },
 }
 
 #[derive(Subcommand)]
@@ -235,11 +242,43 @@ impl Cli {
                     }
                 }
             }
+            Commands::DbComplete { query } => {
+                // Unescape shell escapes in the input query
+                let query = {
+                    let mut unescaped = String::with_capacity(query.len());
+                    let mut chars = query.chars();
+                    while let Some(c) = chars.next() {
+                        if c == '\\' {
+                            if let Some(next) = chars.next() {
+                                unescaped.push(next);
+                            }
+                        } else {
+                            unescaped.push(c);
+                        }
+                    }
+                    unescaped
+                };
+
+                let config = match Config::load() {
+                    Ok(c) => c,
+                    Err(_) => return Ok(()),
+                };
+                let db = match Database::open(&config) {
+                    Ok(d) => d,
+                    Err(_) => return Ok(()),
+                };
+
+                let results = db.complete(&query).unwrap_or_default();
+
+                for r in &results {
+                    println!("{r}");
+                }
+            }
             Commands::Completions { shell } => {
                 let full = Cli::command();
                 let subcommands: Vec<Command> = full
                     .get_subcommands()
-                    .filter(|s| s.get_name() != "completions")
+                    .filter(|s| s.get_name() != "completions" && s.get_name() != "db-complete")
                     .cloned()
                     .collect();
                 let cmd_name = full.get_name().to_string();
diff --git a/src/daemon.rs b/src/daemon.rs
index c794495..5ad6654 100644
--- a/src/daemon.rs
+++ b/src/daemon.rs
@@ -18,14 +18,20 @@ use std::sync::{Arc, Mutex, RwLock};
 use std::thread;
 use std::time::{Duration, Instant, SystemTime};
 
-struct ScrobbleState {
-    track: Option<Track>,
-    start_time: Option<Instant>,
-    timestamp: Option<u64>,
+pub struct ScrobbleState {
+    pub track: Option<Track>,
+    pub start_time: Option<Instant>,
+    pub timestamp: Option<u64>,
+}
+
+impl Default for ScrobbleState {
+    fn default() -> Self {
+        Self::new()
+    }
 }
 
 impl ScrobbleState {
-    fn new() -> Self {
+    pub fn new() -> Self {
         ScrobbleState {
             track: None,
             start_time: None,
@@ -33,7 +39,7 @@ impl ScrobbleState {
         }
     }
 
-    fn start(&mut self, track: Track) {
+    pub fn start(&mut self, track: Track) {
         if track.is_stream {
             crate::debug_eprintln(format_args!(
                 "scrobble: not tracking stream '{}'",
@@ -57,7 +63,7 @@ impl ScrobbleState {
         self.timestamp = Some(ts);
     }
 
-    fn should_scrobble(&self) -> bool {
+    pub fn should_scrobble(&self) -> bool {
         let (Some(track), Some(start)) = (&self.track, self.start_time) else {
             crate::debug_eprintln(format_args!(
                 "scrobble: should_scrobble false — no track or start_time"
@@ -78,7 +84,7 @@ impl ScrobbleState {
         result
     }
 
-    fn should_scrobble_with_params(elapsed: u64, duration_secs: Option<f64>) -> bool {
+    pub fn should_scrobble_with_params(elapsed: u64, duration_secs: Option<f64>) -> bool {
         if elapsed < 30 {
             return false;
         }
@@ -89,86 +95,13 @@ impl ScrobbleState {
         elapsed >= threshold
     }
 
-    fn clear(&mut self) {
+    pub fn clear(&mut self) {
         self.track = None;
         self.start_time = None;
         self.timestamp = None;
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_scrobble_state_new() {
-        let s = ScrobbleState::new();
-        assert!(s.track.is_none());
-        assert!(s.start_time.is_none());
-        assert!(s.timestamp.is_none());
-    }
-
-    #[test]
-    fn test_scrobble_state_clear() {
-        let mut s = ScrobbleState::new();
-        let t = Track {
-            path: PathBuf::from("/test/song.mp3"),
-            title: Some("Test".into()),
-            artist: Some("Artist".into()),
-            album: None,
-            duration_secs: Some(200.0),
-            is_stream: false,
-        };
-        s.start(t);
-        assert!(s.track.is_some());
-        s.clear();
-        assert!(s.track.is_none());
-        assert!(s.start_time.is_none());
-        assert!(s.timestamp.is_none());
-    }
-
-    #[test]
-    fn test_should_scrobble_without_track_returns_false() {
-        assert!(!ScrobbleState::new().should_scrobble());
-    }
-
-    #[test]
-    fn test_should_scrobble_threshold_below_30_seconds() {
-        assert!(!ScrobbleState::should_scrobble_with_params(29, Some(200.0)));
-    }
-
-    #[test]
-    fn test_should_scrobble_threshold_half_duration() {
-        assert!(ScrobbleState::should_scrobble_with_params(100, Some(200.0)));
-    }
-
-    #[test]
-    fn test_should_scrobble_threshold_below_half_duration() {
-        assert!(!ScrobbleState::should_scrobble_with_params(80, Some(200.0)));
-    }
-
-    #[test]
-    fn test_should_scrobble_threshold_capped_at_4min() {
-        assert!(ScrobbleState::should_scrobble_with_params(240, Some(600.0)));
-        assert!(!ScrobbleState::should_scrobble_with_params(
-            239,
-            Some(600.0)
-        ));
-    }
-
-    #[test]
-    fn test_should_scrobble_no_duration_requires_4min() {
-        assert!(ScrobbleState::should_scrobble_with_params(240, None));
-        assert!(!ScrobbleState::should_scrobble_with_params(239, None));
-    }
-
-    #[test]
-    fn test_should_scrobble_short_song() {
-        assert!(ScrobbleState::should_scrobble_with_params(30, Some(60.0)));
-        assert!(!ScrobbleState::should_scrobble_with_params(15, Some(60.0)));
-    }
-}
-
 fn try_scrobble_current(scrobbler: &RwLock<Scrobbler>, state: &mut ScrobbleState) {
     if let Some(ref track) = state.track
         && track.is_stream
@@ -747,30 +680,40 @@ fn process_command(
                 } else {
                     match Config::load() {
                         Ok(config) => match crate::database::Database::open(&config) {
-                            Ok(db) => match db.search_tracks(query_str) {
-                                Ok(tracks) if !tracks.is_empty() => {
-                                    let db_track = &tracks[0];
-                                    let album_tracks = db
-                                        .get_album_tracks_after(
-                                            db_track.album_id,
-                                            db_track.track_number,
-                                            &db_track.path,
-                                        )
-                                        .unwrap_or_default();
-                                    let display = format!(
-                                        "{} - {}",
-                                        db_track.artist_name.as_deref().unwrap_or("unknown"),
-                                        db_track.title,
-                                    );
-                                    let paths: Vec<PathBuf> =
-                                        album_tracks.into_iter().map(|t| t.path).collect();
-                                    (db_track.path.clone(), paths, display)
-                                }
-                                Ok(_) => {
+                            Ok(db) => {
+                                let tracks = match db.resolve_path(query_str) {
+                                    Ok(Some(t)) => t,
+                                    Ok(None) => match db.search_tracks(query_str) {
+                                        Ok(t) => t,
+                                        Err(e) => return format!("Database error: {}\n", e),
+                                    },
+                                    Err(e) => return format!("Database error: {}\n", e),
+                                };
+                                if tracks.is_empty() {
                                     return format!("No tracks found matching '{}'\n", query_str);
                                 }
-                                Err(e) => return format!("Database error: {}\n", e),
-                            },
+                                let db_track = &tracks[0];
+                                let album_paths: Vec<PathBuf> = if tracks.len() > 1 {
+                                    // resolve_path returned full album — use remaining tracks
+                                    tracks[1..].iter().map(|t| t.path.clone()).collect()
+                                } else {
+                                    db.get_album_tracks_after(
+                                        db_track.album_id,
+                                        db_track.track_number,
+                                        &db_track.path,
+                                    )
+                                    .unwrap_or_default()
+                                    .into_iter()
+                                    .map(|t| t.path)
+                                    .collect()
+                                };
+                                let display = format!(
+                                    "{} - {}",
+                                    db_track.artist_name.as_deref().unwrap_or("unknown"),
+                                    db_track.title,
+                                );
+                                (db_track.path.clone(), album_paths, display)
+                            }
                             Err(e) => return format!("Database error: {}\n", e),
                         },
                         Err(e) => return format!("Config error: {}\n", e),
@@ -862,6 +805,24 @@ fn process_command(
             } else {
                 path_str.to_string()
             };
+            // Strip trailing slash so autocompleted Artist/Album/ resolves cleanly
+            let path_str = path_str.trim_end_matches('/').to_string();
+
+            // Unescape backslash sequences (e.g., \! → !) so shell escaping works
+            let path_str = {
+                let mut unescaped = String::with_capacity(path_str.len());
+                let mut chars = path_str.chars();
+                while let Some(c) = chars.next() {
+                    if c == '\\' {
+                        if let Some(next) = chars.next() {
+                            unescaped.push(next);
+                        }
+                    } else {
+                        unescaped.push(c);
+                    }
+                }
+                unescaped
+            };
 
             if path_str.is_empty() {
                 return "Usage: play [now|next|last] <path>\n".to_string();
@@ -1052,7 +1013,132 @@ fn process_command(
                         _ => format!("Error: No audio files found in '{}'\n", path_str),
                     }
                 } else {
-                    format!("File not found: {}\n", path_str)
+                    match Config::load() {
+                        Ok(config) => match crate::database::Database::open(&config) {
+                            Ok(db) => {
+                                // Collect tracks: try hierarchical path first, fallback to search
+                                let tracks = match db.resolve_path(&path_str) {
+                                    Ok(Some(t)) => t,
+                                    Ok(None) => {
+                                        let query = path_str
+                                            .rsplit_once('/')
+                                            .and_then(|(_, after)| {
+                                                (!after.is_empty()).then_some(after)
+                                            })
+                                            .unwrap_or(&path_str);
+                                        match db.search_tracks(query) {
+                                            Ok(t) => t,
+                                            Err(e) => return format!("Database error: {}\n", e),
+                                        }
+                                    }
+                                    Err(e) => return format!("Database error: {}\n", e),
+                                };
+
+                                if tracks.is_empty() {
+                                    return format!("No tracks found matching '{}'\n", path_str);
+                                }
+
+                                let is_album_play = tracks.len() > 1;
+                                if let Ok(mut q) = queue.lock() {
+                                    let was_empty = q.is_empty();
+                                    match position {
+                                        "now" => {
+                                            if let Ok(mut s) = scrobble_state.lock() {
+                                                try_scrobble_current(scrobbler, &mut s);
+                                            }
+                                            for t in tracks.iter().rev() {
+                                                q.insert_after_current(t.path.clone());
+                                            }
+                                            if !was_empty {
+                                                let new_pos = q.position() + 1;
+                                                q.set_position(new_pos);
+                                            }
+                                            if let Some(track) = q.track_at(q.position()) {
+                                                audio.play(track.path.clone());
+                                                send_now_playing(scrobbler, track);
+                                                if let Ok(mut s) = scrobble_state.lock() {
+                                                    s.start(track.clone());
+                                                }
+                                                let fmt = Config::load()
+                                                    .ok()
+                                                    .and_then(|c| c.display_format.clone());
+                                                notification::notify_track(track, fmt.as_deref());
+                                            }
+                                            if is_album_play {
+                                                format!(
+                                                    "Playing now: {} tracks from {}\n",
+                                                    tracks.len(),
+                                                    path_str
+                                                )
+                                            } else {
+                                                format!("Playing now: {}\n", path_str)
+                                            }
+                                        }
+                                        "next" => {
+                                            for t in tracks.iter().rev() {
+                                                q.insert_after_current(t.path.clone());
+                                            }
+                                            if is_album_play {
+                                                format!(
+                                                    "Queued next: {} tracks from {}\n",
+                                                    tracks.len(),
+                                                    path_str
+                                                )
+                                            } else {
+                                                format!("Queued next: {}\n", path_str)
+                                            }
+                                        }
+                                        _ => {
+                                            let was_playing = audio.is_playing();
+                                            for t in &tracks {
+                                                q.add_track(t.path.clone());
+                                            }
+                                            if was_empty && !was_playing {
+                                                if is_album_play {
+                                                    q.shuffle_initial();
+                                                }
+                                                if let Some(track) = q.current() {
+                                                    audio.play(track.path.clone());
+                                                    send_now_playing(scrobbler, track);
+                                                    if let Ok(mut s) = scrobble_state.lock() {
+                                                        s.start(track.clone());
+                                                    }
+                                                    let fmt = Config::load()
+                                                        .ok()
+                                                        .and_then(|c| c.display_format.clone());
+                                                    notification::notify_track(
+                                                        track,
+                                                        fmt.as_deref(),
+                                                    );
+                                                }
+                                                if is_album_play {
+                                                    format!(
+                                                        "Playing: {} tracks from {}\n",
+                                                        tracks.len(),
+                                                        path_str
+                                                    )
+                                                } else {
+                                                    format!("Playing: {}\n", path_str)
+                                                }
+                                            } else if is_album_play {
+                                                format!(
+                                                    "Queued {} tracks from: {}\n",
+                                                    tracks.len(),
+                                                    path_str
+                                                )
+                                            } else {
+                                                format!("Queued: {}\n", path_str)
+                                            }
+                                        }
+                                    }
+                                } else {
+                                    "Error accessing queue\n".to_string()
+                                }
+                            }
+                            Err(e) => format!("Database error: {}\n", e),
+                        },
+                        Err(e) => format!("Config error: {}\n", e),
+                    }
                 }
             }
         }
diff --git a/src/database.rs b/src/database.rs
index 7fd1797..e6f6f6e 100644
--- a/src/database.rs
+++ b/src/database.rs
@@ -45,6 +45,10 @@ pub struct Database {
 
 #[allow(dead_code)]
 impl Database {
+    pub fn conn(&self) -> &Connection {
+        &self.conn
+    }
+
     pub fn open(_config: &crate::config::Config) -> SqlResult<Self> {
         let proj_dirs = ProjectDirs::from("com", "rsplayer", "rsplayer").ok_or_else(|| {
             rusqlite::Error::InvalidPath("Failed to get project directories".into())
@@ -59,7 +63,29 @@ impl Database {
         fs::create_dir_all(&data_dir).ok();
         let db_path = data_dir.join("library.db");
 
-        let conn = Connection::open(&db_path)?;
+        let debug_log = std::env::temp_dir().join("rsp-completion-debug.log");
+        macro_rules! debug_log {
+            ($($arg:tt)*) => {
+                let _ = std::fs::OpenOptions::new()
+                    .create(true)
+                    .append(true)
+                    .open(&debug_log)
+                    .and_then(|mut f| {
+                        use std::io::Write;
+                        writeln!(f, $($arg)*)
+                    });
+            };
+        }
+        debug_log!("[Database::open] db_path: {:?}", db_path);
+        debug_log!("[Database::open] db exists: {}", db_path.exists());
+
+        let conn = match Connection::open(&db_path) {
+            Ok(c) => c,
+            Err(e) => {
+                debug_log!("[Database::open] Connection::open failed: {e}");
+                return Err(e);
+            }
+        };
         let db = Database { conn };
         db.init_schema()?;
         Ok(db)
@@ -279,6 +305,261 @@ impl Database {
         self.get_album_tracks_after(album_id, track_number, &path)
     }
 
+    pub fn complete(&self, query: &str) -> SqlResult<Vec<String>> {
+        let mut results: Vec<String> = Vec::new();
+
+        if query.is_empty() {
+            let mut stmt = self
+                .conn
+                .prepare("SELECT name FROM artists ORDER BY name LIMIT 25")?;
+            let rows = stmt.query_map([], |row| row.get::<_, String>(0))?;
+            for name in rows.flatten() {
+                results.push(format!("{name}/"));
+            }
+            return Ok(results);
+        }
+
+        let has_trailing_slash = query.ends_with('/');
+
+        if has_trailing_slash {
+            let prefix = query.trim_end_matches('/');
+            let segments: Vec<&str> = prefix.split('/').filter(|s| !s.is_empty()).collect();
+
+            match segments.len() {
+                1 => {
+                    let artist = segments[0];
+                    let mut stmt = self.conn.prepare(
+                        "SELECT a.title FROM albums a
+                         JOIN artists ar ON a.artist_id = ar.id
+                         WHERE ar.name LIKE ?1
+                         ORDER BY a.title LIMIT 25",
+                    )?;
+                    let rows = stmt.query_map([artist], |row| row.get::<_, String>(0))?;
+                    for album in rows.flatten() {
+                        results.push(format!("{artist}/{album}/"));
+                    }
+                }
+                2 => {
+                    let artist = segments[0];
+                    let album = segments[1];
+                    let mut stmt = self.conn.prepare(
+                        "SELECT t.title FROM tracks t
+                         JOIN albums a ON t.album_id = a.id
+                         JOIN artists ar ON a.artist_id = ar.id
+                         WHERE ar.name LIKE ?1 AND a.title LIKE ?2
+                         ORDER BY t.track_number, t.title LIMIT 25",
+                    )?;
+                    let rows = stmt.query_map(rusqlite::params![artist, album], |row| {
+                        row.get::<_, String>(0)
+                    })?;
+                    for track in rows.flatten() {
+                        results.push(format!("{artist}/{album}/{track}"));
+                    }
+                }
+                _ => {}
+            }
+        } else {
+            let segments: Vec<&str> = query.split('/').collect();
+
+            match segments.len() {
+                1 => {
+                    let prefix = segments[0];
+                    let like_pattern = format!("%{prefix}%");
+                    let prefix_pattern = format!("{prefix}%");
+
+                    let mut stmt = self.conn.prepare(
+                        "SELECT name FROM artists
+                         WHERE name LIKE ?1
+                         ORDER BY
+                           CASE WHEN name LIKE ?2 THEN 0 ELSE 1 END,
+                           name
+                         LIMIT 25",
+                    )?;
+                    let rows = stmt
+                        .query_map(rusqlite::params![&like_pattern, &prefix_pattern], |row| {
+                            row.get::<_, String>(0)
+                        })?;
+                    for name in rows.flatten() {
+                        results.push(format!("{name}/"));
+                    }
+                }
+                2 => {
+                    let artist = segments[0];
+                    let album_prefix = segments[1];
+                    if artist.is_empty() {
+                        return Ok(results);
+                    }
+
+                    let artist_pattern = format!("%{artist}%");
+                    let artist_prefix = format!("{artist}%");
+                    let album_pattern = format!("%{album_prefix}%");
+                    let album_prefix_pattern = format!("{album_prefix}%");
+
+                    let mut stmt = self.conn.prepare(
+                        "SELECT ar.name, a.title FROM albums a
+                         JOIN artists ar ON a.artist_id = ar.id
+                         WHERE ar.name LIKE ?1 AND a.title LIKE ?2
+                         ORDER BY
+                           CASE WHEN ar.name LIKE ?3 THEN 0 ELSE 1 END,
+                           CASE WHEN a.title LIKE ?4 THEN 0 ELSE 1 END,
+                           ar.name, a.title
+                         LIMIT 25",
+                    )?;
+                    let rows = stmt.query_map(
+                        rusqlite::params![
+                            &artist_pattern,
+                            &album_pattern,
+                            &artist_prefix,
+                            &album_prefix_pattern,
+                        ],
+                        |row| Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?)),
+                    )?;
+                    for (name, album) in rows.flatten() {
+                        results.push(format!("{name}/{album}/"));
+                    }
+                }
+                3 => {
+                    let artist = segments[0];
+                    let album = segments[1];
+                    let track_prefix = segments[2];
+                    if artist.is_empty() || album.is_empty() {
+                        return Ok(results);
+                    }
+
+                    let artist_pattern = format!("%{artist}%");
+                    let artist_prefix = format!("{artist}%");
+                    let album_pattern = format!("%{album}%");
+                    let album_prefix = format!("{album}%");
+                    let track_pattern = format!("%{track_prefix}%");
+                    let track_prefix_pattern = format!("{track_prefix}%");
+
+                    let mut stmt = self.conn.prepare(
+                        "SELECT ar.name, a.title, t.title FROM tracks t
+                         JOIN albums a ON t.album_id = a.id
+                         JOIN artists ar ON a.artist_id = ar.id
+                         WHERE ar.name LIKE ?1 AND a.title LIKE ?2 AND t.title LIKE ?3
+                         ORDER BY
+                           CASE WHEN ar.name LIKE ?4 THEN 0 ELSE 1 END,
+                           CASE WHEN a.title LIKE ?5 THEN 0 ELSE 1 END,
+                           CASE WHEN t.title LIKE ?6 THEN 0 ELSE 1 END,
+                           t.track_number, t.title
+                         LIMIT 25",
+                    )?;
+                    let rows = stmt.query_map(
+                        rusqlite::params![
+                            &artist_pattern,
+                            &album_pattern,
+                            &track_pattern,
+                            &artist_prefix,
+                            &album_prefix,
+                            &track_prefix_pattern,
+                        ],
+                        |row| {
+                            Ok((
+                                row.get::<_, String>(0)?,
+                                row.get::<_, String>(1)?,
+                                row.get::<_, String>(2)?,
+                            ))
+                        },
+                    )?;
+                    for (name, album_title, track) in rows.flatten() {
+                        results.push(format!("{name}/{album_title}/{track}"));
+                    }
+                }
+                _ => {}
+            }
+        }
+
+        results.truncate(25);
+
+        Ok(results)
+    }
+
+    #[allow(dead_code)]
+    pub fn open_in_memory() -> SqlResult<Database> {
+        let conn = Connection::open_in_memory()?;
+        let db = Database { conn };
+        db.init_schema()?;
+        Ok(db)
+    }
+
+    /// Find all tracks in an album by case-insensitive artist and album match.
+    pub fn find_tracks_by_album(&self, artist: &str, album: &str) -> SqlResult<Vec<Track>> {
+        let mut stmt = self.conn.prepare(
+            "SELECT t.id, t.album_id, t.title, t.path, t.duration, t.track_number, ar.name, a.title
+             FROM tracks t
+             JOIN albums a ON t.album_id = a.id
+             JOIN artists ar ON a.artist_id = ar.id
+             WHERE ar.name COLLATE NOCASE = ?1 AND a.title COLLATE NOCASE = ?2
+             ORDER BY t.track_number",
+        )?;
+        let rows = stmt.query_map(rusqlite::params![artist, album], |row| {
+            Ok(Track {
+                id: row.get(0)?,
+                album_id: row.get(1)?,
+                title: row.get(2)?,
+                path: PathBuf::from(row.get::<_, String>(3)?),
+                duration: row.get(4)?,
+                track_number: row.get(5)?,
+                artist_name: Some(row.get(6)?),
+                album_title: Some(row.get(7)?),
+            })
+        })?;
+        rows.collect()
+    }
+
+    /// Find a single track by exact artist, exact album, and track title prefix.
+    /// Returns None if no match found.
+    pub fn find_track_by_parts(
+        &self,
+        artist: &str,
+        album: &str,
+        track_prefix: &str,
+    ) -> SqlResult<Option<Track>> {
+        let pattern = format!("{}%", track_prefix);
+        let mut stmt = self.conn.prepare(
+            "SELECT t.id, t.album_id, t.title, t.path, t.duration, t.track_number, ar.name, a.title
+             FROM tracks t
+             JOIN albums a ON t.album_id = a.id
+             JOIN artists ar ON a.artist_id = ar.id
+             WHERE ar.name COLLATE NOCASE = ?1 AND a.title COLLATE NOCASE = ?2 AND t.title LIKE ?3
+             ORDER BY t.track_number LIMIT 1",
+        )?;
+        let mut rows = stmt.query_map(rusqlite::params![artist, album, pattern], |row| {
+            Ok(Track {
+                id: row.get(0)?,
+                album_id: row.get(1)?,
+                title: row.get(2)?,
+                path: PathBuf::from(row.get::<_, String>(3)?),
+                duration: row.get(4)?,
+                track_number: row.get(5)?,
+                artist_name: Some(row.get(6)?),
+                album_title: Some(row.get(7)?),
+            })
+        })?;
+        match rows.next() {
+            Some(Ok(t)) => Ok(Some(t)),
+            Some(Err(e)) => Err(e),
+            None => Ok(None),
+        }
+    }
+
+    /// Resolve a hierarchical path like "Artist/Album" or "Artist/Album/Track"
+    /// to DB tracks. Returns None if the path isn't hierarchical (single part
+    /// or 4+ parts) — the caller should fall back to search_tracks().
+    pub fn resolve_path(&self, path: &str) -> SqlResult<Option<Vec<Track>>> {
+        let path = path.strip_suffix('/').unwrap_or(path);
+        let parts: Vec<&str> = path.splitn(3, '/').collect();
+        match parts.len() {
+            2 => Ok(Some(self.find_tracks_by_album(parts[0], parts[1])?)),
+            3 => match self.find_track_by_parts(parts[0], parts[1], parts[2])? {
+                Some(t) => Ok(Some(vec![t])),
+                None => Ok(Some(vec![])),
+            },
+            _ => Ok(None),
+        }
+    }
+
     pub fn search_tracks(&self, query: &str) -> SqlResult<Vec<Track>> {
         let mut stmt = self.conn.prepare(
             "SELECT t.id, t.album_id, t.title, t.path, t.duration, t.track_number, ar.name, a.title
@@ -336,11 +617,19 @@ pub fn extract_metadata(path: &Path) -> (String, String, String, Option<i32>, Op
         .and_then(|s| s.to_str())
         .unwrap_or("Unknown");
 
-    (
-        grandparent.to_string(),
-        parent.to_string(),
-        file_stem.to_string(),
-        None,
-        None,
-    )
+    let fs_artist = grandparent.to_string();
+    let fs_album = parent.to_string();
+    let fs_title = file_stem.to_string();
+
+    if let Some(audio_meta) = crate::queue::extract_metadata(path) {
+        (
+            audio_meta.artist.unwrap_or(fs_artist),
+            audio_meta.album.unwrap_or(fs_album),
+            audio_meta.title.unwrap_or(fs_title),
+            audio_meta.track_number,
+            audio_meta.duration_secs.map(|d| d as u64),
+        )
+    } else {
+        (fs_artist, fs_album, fs_title, None, None)
+    }
 }
diff --git a/src/queue.rs b/src/queue.rs
index 3c1c6fa..7675ddd 100644
--- a/src/queue.rs
+++ b/src/queue.rs
@@ -21,6 +21,7 @@ pub struct AudioMetadata {
     pub title: Option<String>,
     pub artist: Option<String>,
     pub album: Option<String>,
+    pub track_number: Option<i32>,
     pub duration_secs: Option<f64>,
 }
 
@@ -64,16 +65,27 @@ pub fn extract_metadata(path: &Path) -> Option<AudioMetadata> {
                     Some(StandardTag::Artist(value)) => {
                         metadata.artist = Some(value.to_string());
                     }
+                    Some(StandardTag::AlbumArtist(value)) => {
+                        metadata.artist = Some(value.to_string());
+                    }
                     Some(StandardTag::Album(value)) => {
                         metadata.album = Some(value.to_string());
                     }
+                    Some(StandardTag::TrackNumber(value)) => {
+                        metadata.track_number = value.to_string().parse().ok();
+                    }
                     _ => {}
                 }
             }
         }
     }
 
-    if metadata.title.is_some() || metadata.artist.is_some() || metadata.album.is_some() {
+    if metadata.title.is_some()
+        || metadata.artist.is_some()
+        || metadata.album.is_some()
+        || metadata.track_number.is_some()
+        || metadata.duration_secs.is_some()
+    {
         Some(metadata)
     } else {
         None
diff --git a/src/scrobbler.rs b/src/scrobbler.rs
index e133669..40d3ce6 100644
--- a/src/scrobbler.rs
+++ b/src/scrobbler.rs
@@ -162,7 +162,7 @@ impl Scrobbler {
         }
     }
 
-    fn sign_lastfm(params: &BTreeMap<&str, &str>, secret: &str) -> String {
+    pub fn sign_lastfm(params: &BTreeMap<&str, &str>, secret: &str) -> String {
         let mut concat = String::new();
         for (key, value) in params {
             concat.push_str(key);
@@ -333,23 +333,3 @@ impl Scrobbler {
         Ok(())
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_sign_lastfm() {
-        let params = BTreeMap::from([
-            ("api_key", "abc123"),
-            ("method", "track.scrobble"),
-            ("sk", "session_key"),
-            ("track", "Test Track"),
-            ("artist", "Test Artist"),
-            ("timestamp", "1234567890"),
-        ]);
-        let sig = Scrobbler::sign_lastfm(&params, "sekrit");
-        assert_eq!(sig.len(), 32);
-        assert!(sig.chars().all(|c| c.is_ascii_hexdigit()));
-    }
-}