Added tracks to db, beginning to get playlist creation

src/main.rs

@@ -6,12 +6,32 @@ mod metadata;
 use std::env;
 use std::path::Path;
 
+fn usage(program: &str) -> ! {
+    eprintln!("Usage:");
+    eprintln!("  {program} index [-v] <directory>");
+    eprintln!("  {program} build <file>");
+    std::process::exit(1);
+}
+
 fn main() {
     let args: Vec<String> = env::args().collect();
-    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" {
+    if args.len() < 2 {
+        usage(&args[0]);
+    }
+
+    match args[1].as_str() {
+        "index" => cmd_index(&args),
+        "build" => cmd_build(&args),
+        _ => usage(&args[0]),
+    }
+}
+
+fn cmd_index(args: &[String]) {
+    let verbose = args.iter().any(|a| a == "-v");
+    let rest: Vec<&String> = args.iter().skip(2).filter(|a| *a != "-v").collect();
+
+    if rest.len() != 1 {
         eprintln!("Usage: {} index [-v] <directory>", args[0]);
         std::process::exit(1);
     }
@@ -26,7 +46,7 @@ fn main() {
 
     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());
+    let dir = Path::new(rest[0].as_str());
 
     for path in filesystem::walk_music_files(dir) {
         let artist_mbid = match metadata::read_artist_mbid(&path) {
@@ -38,6 +58,8 @@ fn main() {
             }
         };
 
+        let recording_mbid = metadata::read_track_mbid(&path).ok().flatten();
+
         let already_indexed = match db::artist_exists(&conn, &artist_mbid) {
             Ok(exists) => exists,
             Err(e) => {
@@ -49,29 +71,69 @@ fn main() {
         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 !already_indexed {
             if verbose {
-                println!("Skipping {display_name} (already indexed)");
+                println!("Indexing {display_name}...");
             }
-            continue;
-        }
 
-        if verbose {
-            println!("Indexing {display_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}");
+            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}");
+                        continue;
+                    }
+                }
+                Err(e) => {
+                    eprintln!("Last.fm error for {artist_mbid}: {e}");
+                    continue;
                 }
             }
-            Err(e) => eprintln!("Last.fm error for {artist_mbid}: {e}"),
+        } else if verbose {
+            println!("Skipping {display_name} (already indexed)");
+        }
+
+        let path_str = path.to_string_lossy();
+        if let Err(e) = db::insert_track(&conn, &path_str, &artist_mbid, recording_mbid.as_deref()) {
+            eprintln!("DB error inserting track {}: {e}", path.display());
+        }
+    }
+}
+
+fn cmd_build(args: &[String]) {
+    if args.len() != 3 {
+        eprintln!("Usage: {} build <file>", args[0]);
+        std::process::exit(1);
+    }
+
+    let path = Path::new(&args[2]);
+    let artist_mbid = match metadata::read_artist_mbid(path) {
+        Ok(Some(mbid)) => mbid,
+        Ok(None) => {
+            eprintln!("{}: no artist MBID found", path.display());
+            std::process::exit(1);
+        }
+        Err(e) => {
+            eprintln!("{}: could not read artist MBID: {e}", path.display());
+            std::process::exit(1);
+        }
+    };
+
+    let conn = db::open("playlists.db").expect("failed to open database");
+
+    match db::get_available_similar_artists(&conn, &artist_mbid) {
+        Ok(artists) => {
+            for (name, score) in &artists {
+                println!("{name} ({score:.4})");
+            }
+        }
+        Err(e) => {
+            eprintln!("DB error: {e}");
+            std::process::exit(1);
         }
     }
 }