Building up a little db of "similar artists"

src/main.rs

@@ -1,3 +1,4 @@
+mod db;
 mod filesystem;
 mod lastfm;
 mod metadata;
@@ -6,62 +7,71 @@ use std::env;
 use std::path::Path;
 
 fn main() {
-    dotenvy::dotenv().ok();
-
     let args: Vec<String> = env::args().collect();
-    if args.len() != 2 {
-        eprintln!("Usage: {} <directory>", args[0]);
+    let verbose = args.iter().any(|a| a == "-v");
+    let rest: Vec<&String> = args.iter().skip(1).filter(|a| *a != "-v").collect();
+
+    if rest.len() != 2 || rest[0] != "index" {
+        eprintln!("Usage: {} index [-v] <directory>", args[0]);
         std::process::exit(1);
     }
 
-    let api_key = env::var("LASTFM_API_KEY").unwrap_or_default();
-    let mut lastfm = if api_key.is_empty() {
-        eprintln!("Warning: LASTFM_API_KEY not set, skipping similar artist lookups");
-        None
-    } else {
-        Some(lastfm::LastfmClient::new(api_key))
-    };
+    dotenvy::dotenv().ok();
 
-    let dir = Path::new(&args[1]);
+    let api_key = env::var("LASTFM_API_KEY").unwrap_or_default();
+    if api_key.is_empty() {
+        eprintln!("Error: LASTFM_API_KEY not set");
+        std::process::exit(1);
+    }
+
+    let conn = db::open("playlists.db").expect("failed to open database");
+    let lastfm = lastfm::LastfmClient::new(api_key);
+    let dir = Path::new(rest[1].as_str());
 
     for path in filesystem::walk_music_files(dir) {
-        match metadata::read_all_metadata(&path) {
-            Ok(Some(entries)) => {
-                println!("{}", path.display());
-                for entry in &entries {
-                    println!("  {:30} {}", entry.key, entry.value);
-                }
-            }
-            Ok(None) => {
-                println!("{}", path.display());
-                println!("  (no metadata tags found)");
-            }
+        let artist_mbid = match metadata::read_artist_mbid(&path) {
+            Ok(Some(mbid)) => mbid,
+            Ok(None) => continue,
             Err(e) => {
-                eprintln!("{}: could not read metadata: {e}", path.display());
+                eprintln!("{}: could not read artist MBID: {e}", path.display());
+                continue;
             }
+        };
+
+        let already_indexed = match db::artist_exists(&conn, &artist_mbid) {
+            Ok(exists) => exists,
+            Err(e) => {
+                eprintln!("DB error checking artist {artist_mbid}: {e}");
+                continue;
+            }
+        };
+
+        let artist_name = metadata::read_artist_name(&path).ok().flatten();
+        let display_name = artist_name.as_deref().unwrap_or(&artist_mbid);
+
+        if already_indexed {
+            if verbose {
+                println!("Skipping {display_name} (already indexed)");
+            }
+            continue;
         }
 
-        if let Some(client) = lastfm.as_mut() {
-            let artist_mbid = match metadata::read_artist_mbid(&path) {
-                Ok(Some(mbid)) => mbid,
-                Ok(None) => continue,
-                Err(e) => {
-                    eprintln!("{}: could not read artist MBID: {e}", path.display());
-                    continue;
-                }
-            };
+        if verbose {
+            println!("Indexing {display_name}...");
+        }
 
-            match client.get_similar_artists(&artist_mbid) {
-                Ok(similar) => {
-                    if !similar.is_empty() {
-                        println!("  Similar artists:");
-                        for a in similar.iter().take(50) {
-                            println!("    {:.2}  {}", a.match_score, a.name);
-                        }
-                    }
+        match lastfm.get_similar_artists(&artist_mbid) {
+            Ok(similar) => {
+                if let Err(e) = db::insert_artist_with_similar(
+                    &conn,
+                    &artist_mbid,
+                    artist_name.as_deref(),
+                    &similar,
+                ) {
+                    eprintln!("DB error inserting artist {artist_mbid}: {e}");
                 }
-                Err(e) => eprintln!("  Warning: similar artists lookup failed: {e}"),
             }
+            Err(e) => eprintln!("Last.fm error for {artist_mbid}: {e}"),
         }
     }
 }