Added help command, fixed Spotify search

Cargo.lock

@@ -713,6 +713,18 @@ dependencies = [
  "cfg-if",
 ]
 
+[[package]]
+name = "enum_dispatch"
+version = "0.3.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa18ce2bc66555b3218614519ac839ddb759a7d6720732f979ef8d13be147ecd"
+dependencies = [
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.101",
+]
+
 [[package]]
 name = "equivalent"
 version = "1.0.2"
@@ -979,8 +991,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592"
 dependencies = [
  "cfg-if",
+ "js-sys",
  "libc",
  "wasi 0.11.0+wasi-snapshot-preview1",
+ "wasm-bindgen",
 ]
 
 [[package]]
@@ -1766,6 +1780,17 @@ dependencies = [
  "pkg-config",
 ]
 
+[[package]]
+name = "maybe-async"
+version = "0.2.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5cf92c10c7e361d6b99666ec1c6f9805b0bea2c3bd8c78dc6fe98ac5bd78db11"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.101",
+]
+
 [[package]]
 name = "maybe-rayon"
 version = "0.1.1"
@@ -2574,6 +2599,7 @@ dependencies = [
  "system-configuration 0.6.1",
  "tokio",
  "tokio-native-tls",
+ "tokio-socks",
  "tower",
  "tower-service",
  "url",
@@ -2638,6 +2664,64 @@ dependencies = [
  "zeroize",
 ]
 
+[[package]]
+name = "rspotify"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77beedc33ecff4c39e8ef0e6f7ebc8d849f3ffebbeb786f9997d96f0d9cf4017"
+dependencies = [
+ "async-stream",
+ "async-trait",
+ "base64 0.22.1",
+ "chrono",
+ "futures",
+ "getrandom 0.2.16",
+ "log",
+ "maybe-async",
+ "rspotify-http",
+ "rspotify-macros",
+ "rspotify-model",
+ "serde",
+ "serde_json",
+ "sha2",
+ "thiserror 2.0.12",
+ "url",
+]
+
+[[package]]
+name = "rspotify-http"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fde1ea9e2a49698cffbc994a83f5f909b37736c31cccb202f9577e8a32df3a63"
+dependencies = [
+ "async-trait",
+ "log",
+ "maybe-async",
+ "reqwest 0.12.15",
+ "serde_json",
+ "thiserror 2.0.12",
+]
+
+[[package]]
+name = "rspotify-macros"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee3dfb51ee54bd754ad76e96ad60a3b64bc70ae33a89261d9dbabc4c148a496f"
+
+[[package]]
+name = "rspotify-model"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "018f29a6a8c47cfe7923c48140ed546a395f660c7af05b73e6001d4505f89c8d"
+dependencies = [
+ "chrono",
+ "enum_dispatch",
+ "serde",
+ "serde_json",
+ "strum",
+ "thiserror 2.0.12",
+]
+
 [[package]]
 name = "rustc-demangle"
 version = "0.1.24"
@@ -3347,6 +3431,27 @@ dependencies = [
  "unicode-properties",
 ]
 
+[[package]]
+name = "strum"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af23d6f6c1a224baef9d3f61e287d2761385a5b88fdab4eb4c6f11aeb54c4bcf"
+dependencies = [
+ "strum_macros",
+]
+
+[[package]]
+name = "strum_macros"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7695ce3845ea4b33927c055a39dc438a45b059f7c1b3d91d38d10355fb8cbca7"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.101",
+]
+
 [[package]]
 name = "subtle"
 version = "2.6.1"
@@ -3684,6 +3789,18 @@ dependencies = [
  "tokio",
 ]
 
+[[package]]
+name = "tokio-socks"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d4770b8024672c1101b3f6733eab95b18007dbe0847a8afe341fcf79e06043f"
+dependencies = [
+ "either",
+ "futures-util",
+ "thiserror 1.0.69",
+ "tokio",
+]
+
 [[package]]
 name = "tokio-stream"
 version = "0.1.17"
@@ -4153,7 +4270,7 @@ dependencies = [
 
 [[package]]
 name = "watcat"
-version = "0.1.0"
+version = "0.5.0"
 dependencies = [
  "arabic_reshaper",
  "dotenvy",
@@ -4165,6 +4282,7 @@ dependencies = [
  "palette",
  "reqwest 0.12.15",
  "reqwest-middleware",
+ "rspotify",
  "serenity",
  "sqlx",
  "tokio",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "watcat"
-version = "0.2.0"
+version = "0.5.0"
 edition = "2024"
 
 [dependencies]
@@ -11,6 +11,7 @@ reqwest = "0.12"
 reqwest-middleware = "0.4.2"
 http-cache-reqwest = "0.15.1"
 palette = "0.7.6"
+rspotify = "0.15.0"
 # text rendering dependencies
 arabic_reshaper = "0.4.2"
 unicode-bidi = "0.3.18"

README.md

@@ -28,7 +28,12 @@ init the database ``sqlx migrate run``
 TODO
 ----
 
-+ ~~literally just add the text~~
++ ~~add art and lastfm url fetching~~
-+ add easter egg
++ ~~add help command~~
++ ~~refactor to combine repeated parts of art, url, and fmi.~~
++ use macro for commands
++ use Option instead of empty string sentinel value
++ add cache for album art colors
++ ~~add spotify link fetching~~
 + make various parameters user-configurable
 + use tiny-skia instead of magick-rust?

src/main.rs

@@ -11,10 +11,13 @@ use serenity::model::id::UserId;
 use serenity::prelude::*;
 
 extern crate magick_rust;
-use magick_rust::{ColorspaceType, CompositeOperator, MagickWand, PixelWand, magick_wand_genesis, FilterType};
+use magick_rust::{
+    ColorspaceType, CompositeOperator, FilterType, MagickWand, PixelWand, magick_wand_genesis,
+};
 
 use std::env;
-use std::sync::Once;
+use std::sync::{Arc, Once};
+use tokio::sync::Mutex;
 
 use palette::color_difference::ImprovedCiede2000;
 use palette::lab::Lab;
@@ -23,6 +26,9 @@ use palette::white_point::D65;
 extern crate sqlx;
 use sqlx::sqlite::SqlitePool;
 
+use rspotify::model::{enums::types::SearchType, search::SearchResult};
+use rspotify::{ClientCredsSpotify, Credentials, clients::BaseClient};
+
 use imagetext::fontdb::FontDB;
 use imagetext::superfont::SuperFont;
 
@@ -48,13 +54,13 @@ macro_rules! now {
 
 macro_rules! log {
 	($a:expr) => {
-		if env::var("DEBUG").unwrap_or("0".to_string()) == "1" {
+		if env::var("DEBUG").unwrap_or("0".to_owned()) == "1" {
 			println!(concat!("debug: {} ", $a), now!())
 		}
 	};
 
 	($a:expr, $($b:expr),+) => {
-		if env::var("DEBUG").unwrap_or("0".to_string()) == "1" {
+		if env::var("DEBUG").unwrap_or("0".to_owned()) == "1" {
 			println!(concat!("debug: {} ", $a), now!(), $($b),+)
 		}
 	};
@@ -75,7 +81,7 @@ macro_rules! handle_magick_option {
     ($a: expr, $b: literal) => {
         match $a {
             Some(res) => res,
-            None => return Reply::Text($b.to_string()),
+            None => return Reply::Text($b.to_owned()),
         }
     };
 }
@@ -114,36 +120,108 @@ fn validate_color(col: &PixelWand) -> Option<Lab> {
     Some(Lab::<D65>::from_components(color_raw))
 }
 
-async fn fmi(ctx: &Context, arg: &str, id: UserId, avatar: Option<String>) -> Reply {
+async fn get_track(
+    ctx: &Context,
+    arg: &str,
+    id: UserId,
+) -> Result<lastfm::track::NowPlayingTrack, Reply> {
     let lastfm_user = match arg {
         "" => get_lastfm_username(ctx, id).await,
-        _ => Some(arg.to_string()),
+        _ => Some(arg.to_owned()),
     };
     let lastfm_client = match lastfm_user {
         Some(s) => lastfm::Client::<String, String>::from_env(s),
-        None => return Reply::Text("No last.fm username set.".to_string()),
+        None => return Err(Reply::Text("No last.fm username set.".to_owned())),
     };
     let now_playing = match lastfm_client.now_playing().await {
         Ok(np) => np,
-        Err(e) => return Reply::Text(format!("Error: grabbing last.fm user data failed {e}")),
+        Err(e) => {
+            return Err(Reply::Text(format!(
+                "Error: grabbing last.fm user data failed {e}"
+            )));
+        }
     };
     let track = match now_playing {
         Some(track) => track,
-        None => return Reply::Text("Nothing playing.".to_string()),
+        None => return Err(Reply::Text("Nothing playing.".to_owned())),
+    };
+    Ok(track)
+}
+
+async fn art(ctx: &Context, arg: &str, id: UserId) -> Reply {
+    let track = match get_track(ctx, arg, id).await {
+        Ok(track) => track,
+        Err(e) => return e,
+    };
+    let track_art = match track.image.extralarge {
+        Some(track_art) => track_art,
+        None => return Reply::Text("Error: getting image uri failed".to_owned()),
+    };
+    Reply::Text(track_art.to_owned())
+}
+
+async fn url(ctx: &Context, arg: &str, id: UserId) -> Reply {
+    let track = match get_track(ctx, arg, id).await {
+        Ok(track) => track,
+        Err(e) => return e,
+    };
+    Reply::Text(track.url)
+}
+
+async fn spot(ctx: &Context, arg: &str, id: UserId) -> Reply {
+    let track = match get_track(ctx, arg, id).await {
+        Ok(track) => track,
+        Err(e) => return e,
+    };
+    let mut data = ctx.data.write().await;
+    let spotify_option = data
+        .get_mut::<SpotifyHaver>()
+        .expect("Failed to have spotify option");
+    if spotify_option.is_none() {
+        return Reply::Text("Unable to use Spotify command: Contact bot Administrator.".to_owned());
+    }
+    let spotify_arc_mutex = spotify_option.as_mut().unwrap();
+    //let spotify_arc_mutex_ref = Arc::clone(&spotify_arc_mutex);
+    let spotify_client = spotify_arc_mutex.lock().await;
+    let search = spotify_client
+        .search(
+            format!(r#"track:"{}" album:"{}" artist:"{}""#, track.name.replace("\"", ""), track.album.replace("\"", ""), track.artist.name.replace("\"", "")).as_str(),
+            SearchType::Track,
+            None,
+            None,
+            None,
+            None,
+        )
+        .await;
+    let tracks = match search {
+        Ok(SearchResult::Tracks(track_page)) => track_page,
+        Err(e) => return Reply::Text(format!("Failed to get track {e}")),
+        _ => return Reply::Text("Spotify search failed".to_owned()),
+    };
+    match &tracks.items[0].external_urls.get("spotify") {
+        Some(url) => Reply::Text(url.to_owned().to_owned()),
+        None => Reply::Text("Unable to get spotify url".to_owned()),
+    }
+}
+
+async fn fmi(ctx: &Context, arg: &str, id: UserId, avatar: Option<String>) -> Reply {
+    let track = match get_track(ctx, arg, id).await {
+        Ok(track) => track,
+        Err(e) => return e,
     };
     let track_info = text::TrackInfo {
-    	title: track.name,
+        title: track.name,
-    	artist: track.artist.name,
+        artist: track.artist.name,
-    	album: track.album,
+        album: track.album,
     };
     let image_uri = match track.image.extralarge {
         Some(iu) => iu,
-        None => return Reply::Text("Error: getting image uri failed".to_string()),
+        None => return Reply::Text("Error: getting image uri failed".to_owned()),
     };
 
     let image = match get_image(ctx, image_uri.as_str()).await {
         Ok(i) => i,
-        Err(e) => return Reply::Text(format!("{}", e)),
+        Err(e) => return Reply::Text(format!("{e}")),
     };
     let mut base_color = PixelWand::new();
     let mut white = PixelWand::new();
@@ -213,14 +291,13 @@ async fn fmi(ctx: &Context, arg: &str, id: UserId, avatar: Option<String>) -> Re
         );
     }
 
-    
     let use_dark_color = match validate_color(&colors[0]) {
-    	Some(color) => {
+        Some(color) => {
-   			let black_delta_e = Lab::<D65>::new(0.0, 0.0, 0.0).improved_difference(color);
+            let black_delta_e = Lab::<D65>::new(0.0, 0.0, 0.0).improved_difference(color);
-   			let white_delta_e = Lab::<D65>::new(100.0, 0.0, 0.0).improved_difference(color);
+            let white_delta_e = Lab::<D65>::new(100.0, 0.0, 0.0).improved_difference(color);
-    		black_delta_e > white_delta_e
+            black_delta_e > white_delta_e
-    	}
+        }
-    	_ => false
+        _ => false,
     };
 
     handle_magick_result!(white.set_color("#ffffff"), "Failed to init white");
@@ -271,15 +348,24 @@ async fn fmi(ctx: &Context, arg: &str, id: UserId, avatar: Option<String>) -> Re
         "Failed to set avatar colorspace"
     );
 
-	let (image_width, image_height) = (548, 147);
+    let (image_width, image_height) = (548, 147);
     let data = ctx.data.write().await;
-    let fonts = data
+    let fonts = data.get::<FontsHaver>().expect("Failed to load fonts");
-        .get::<FontsHaver>().expect("Failed to load fonts");
+    let text_image_blob = match text::fmi_text(
-    let text_image_blob = match text::fmi_text(image_width, image_height, track_info, fonts, 19.0, use_dark_color) {
+        image_width,
-    	Ok(bytes) => bytes,
+        image_height,
-    	Err(e) => return Reply::Text(e),
+        track_info,
+        fonts,
+        19.0,
+        use_dark_color,
+    ) {
+        Ok(bytes) => bytes,
+        Err(e) => return Reply::Text(e),
     };
-    handle_magick_result!(text_image_wand.read_image_blob(&text_image_blob), "Failed to load text image");
+    handle_magick_result!(
+        text_image_wand.read_image_blob(&text_image_blob),
+        "Failed to load text image"
+    );
     handle_magick_result!(
         text_image_wand.transform_image_colorspace(ColorspaceType::Lab),
         "Failed to set avatar colorspace"
@@ -310,17 +396,17 @@ async fn fmi(ctx: &Context, arg: &str, id: UserId, avatar: Option<String>) -> Re
         "Failed to combine mask"
     );
     #[cfg(debug_assertions)]
-    if env::var("DEBUG_IMAGE").unwrap_or("0".to_string()) == "1" {
+    if env::var("DEBUG_IMAGE").unwrap_or("0".to_owned()) == "1" {
-    	handle_magick_result!(
+        handle_magick_result!(
-    	    main_wand.compose_images(
+            main_wand.compose_images(
-    	        &art_wand_cluster,
+                &art_wand_cluster,
-    	        CompositeOperator::SrcOver,
+                CompositeOperator::SrcOver,
-    	        false,
+                false,
-    	        160,
+                160,
-    	        12
+                12
-    	    ),
+            ),
-    	    "Failed to combine debug image"
+            "Failed to combine debug image"
-    	);
+        );
     }
     handle_magick_result!(
         main_wand.compose_images(&text_image_wand, CompositeOperator::SrcOver, false, 0, 0),
@@ -333,26 +419,83 @@ async fn fmi(ctx: &Context, arg: &str, id: UserId, avatar: Option<String>) -> Re
     Reply::Image(main_wand.write_image_blob("png").unwrap())
 }
 
-async fn set(ctx: &Context, arg: &str, id: UserId) -> Reply {
+fn help(arg: &str) -> Reply {
-    set_lastfm_username(ctx, id, arg.to_string()).await;
+    Reply::Text(format!(
-    Reply::Text(format!("set user {}", arg))
+        "```{}```",
+        match arg {
+            "" =>
+            	"usage: .k <img|set|art|url|spotify|help> [lastfm user]\n       .k img [lastfm user]:  get now playing\n       .k set <lastfm user>:  sets your username for the future\n       .k art [lastfm user]:  get now playing album art\n       .k url [lastfm user]:  get now playing lastfm url\n       .k spot [lastfm user]: get now playing spotify link\n       .k help [command]: displays a help message"
+                .to_owned(),
+            "img" | "fmi" | "fm" | "get" =>
+				"usage: .k img [lastfm user]\nreturns a pretty-printed image of the user's now playing track on last.fm, using the album art's colors to theme the image. see also: .k set\naliases: .kfmi, .k <fmi|get|img>, .kf, .ki, or even just .k"
+                .to_owned(),
+            "set" =>
+            	"usage: .k set <lastfm user>\nties a lastfm username to your account. use this to not require your username for .k fmi every time, for example\naliases: .kset"
+                .to_owned(),
+            "art" =>
+				"usage: .k art [lastfm user]\nfetches user's now playing track's album art\naliases: .k art, .kart, .ka"
+                .to_owned(),
+            "url" | "link" =>
+            	"usage: .k url [lastfm user]\nfetches a lastfm link to user's now playing track\naliases: .k url, .k link, .kl, .ku, .kurl"
+                .to_owned(),
+            "spot" | "spotify" =>
+            	"usage: .k spotify [lastfm user]\nsearches spotify for the user's now playing track and returns a link to that track\naliases: .k <spot|spotify>, .ks, .kspot"
+                .to_owned(),
+            _ => format!("unknown command: {arg}"),
+        }
+    ))
 }
 
+async fn set(ctx: &Context, arg: &str, id: UserId) -> Reply {
+    set_lastfm_username(ctx, id, arg.to_owned()).await;
+    Reply::Text(format!("set user {arg}"))
+}
+
+//macro_rules! cmd {
+//	(c:lit, abbr:lit, a:ident) => {
+//		(".k", $c, $a) | (".k", $a, $c) | (concat!(".k", $abbr), $ident, "")
+//	}
+//}
+
 #[async_trait]
 impl EventHandler for Handler {
     async fn message(&self, ctx: Context, msg: Message) {
         let mut cmd_iter = msg.content.split(" ");
         let cmd = cmd_iter.next().unwrap_or("");
-        let arg = cmd_iter.next().unwrap_or("");
+        let arg1 = cmd_iter.next().unwrap_or("");
-        let resp = match cmd {
+        let arg2 = cmd_iter.next().unwrap_or("");
-            ".fmi" => {
+        let resp = match (cmd, arg1, arg2) {
-                log!("{} received", msg.content);
+            (".set", arg, "") | (".k", "set", arg) | (".kset", arg, "") => {
-                Some(fmi(&ctx, arg, msg.author.id, msg.author.avatar_url()).await)
-            }
-            ".set" => {
                 log!("{} received", msg.content);
                 Some(set(&ctx, arg, msg.author.id).await)
             }
+            (".k", "art", arg) | (".k", arg, "art") | (".ka" | ".kart", arg, "") => {
+                log!("{} received", msg.content);
+                Some(art(&ctx, arg, msg.author.id).await)
+            }
+            (".k", "url" | "uri" | "link", arg)
+            | (".k", arg, "url" | "uri" | "link")
+            | (".ku" | ".kl" | ".kurl", arg, "") => {
+                log!("{} received", msg.content);
+                Some(url(&ctx, arg, msg.author.id).await)
+            }
+            (".k", "spot" | "spotify", arg)
+            | (".k", arg, "spot" | "spotify")
+            | (".ks" | ".kspot", arg, "") => {
+                log!("{} received", msg.content);
+                Some(spot(&ctx, arg, msg.author.id).await)
+            }
+            (".k", "help" | "h" | "?", arg)
+            | (".k", arg, "help" | "h" | "?")
+            | (".kh" | ".k?", arg, "") => {
+                log!("{} received", msg.content);
+                Some(help(arg))
+            }
+            (".fmi" | ".k" | ".kf" | ".ki" | ".kfmi", arg, "")
+            | (".k", "fm" | "fmi" | "get" | "img", arg) => {
+                log!("{} received", msg.content);
+                Some(fmi(&ctx, arg, msg.author.id, msg.author.avatar_url()).await)
+            }
             _ => None,
         };
         if let Some(reply) = resp {
@@ -384,7 +527,12 @@ impl TypeMapKey for PoolHaver {
 
 struct FontsHaver;
 impl TypeMapKey for FontsHaver {
-	type Value = (SuperFont<'static>, SuperFont<'static>);
+    type Value = (SuperFont<'static>, SuperFont<'static>);
+}
+
+struct SpotifyHaver;
+impl TypeMapKey for SpotifyHaver {
+    type Value = Option<Arc<Mutex<ClientCredsSpotify>>>;
 }
 
 struct DBResponse {
@@ -441,9 +589,7 @@ async fn set_lastfm_username(ctx: &Context, id: UserId, user: String) {
 async fn get_image(ctx: &Context, url: &str) -> Result<Vec<u8>, reqwest_middleware::Error> {
     log!("get {}", url);
     let data = ctx.data.write().await;
-    let http = data
+    let http = data.get::<HttpHaver>().expect("Failed to get http client");
-        .get::<HttpHaver>()
-        .expect("Failed to get http client");
     match http.get(url).send().await {
         Ok(resp) => {
             log!("response received");
@@ -483,8 +629,9 @@ async fn main() {
         }))
         .build();
 
-   	FontDB::load_from_dir("fonts"); //singlet instance??? wha?????
+    FontDB::load_from_dir("fonts"); //singlet instance??? wha?????
-    let regular_fonts = FontDB::query("
+    let regular_fonts = FontDB::query(
+        "
     	NotoSans-Regular
     	NotoSansHK-Regular
     	NotoSansJP-Regular
@@ -496,8 +643,11 @@ async fn main() {
     	NotoEmoji-Regular
     	Symbola
     	Unifont
-    ").expect("Failed to load regular fonts");
+    ",
-    let bold_fonts = FontDB::query("
+    )
+    .expect("Failed to load regular fonts");
+    let bold_fonts = FontDB::query(
+        "
     	NotoSans-SemiBold
     	NotoSansJP-Medium
     	NotoSansKR-Medium
@@ -508,7 +658,15 @@ async fn main() {
     	NotoEmoji-Medium
     	Symbola
     	Unifont
-    ").expect("Failed to load bold fonts");
+    ",
+    )
+    .expect("Failed to load bold fonts");
+
+    let spotify_creds = Credentials::from_env();
+    let spotify = spotify_creds.map(ClientCredsSpotify::new);
+    if let Some(spotify_client) = &spotify {
+        let _ = &spotify_client.request_token().await.unwrap();
+    }
 
     let mut discord_client = Client::builder(&token, intents)
         .event_handler(Handler)
@@ -520,6 +678,7 @@ async fn main() {
         data.insert::<PoolHaver>(pool);
         data.insert::<HttpHaver>(http);
         data.insert::<FontsHaver>((regular_fonts, bold_fonts));
+        data.insert::<SpotifyHaver>(spotify.map(Mutex::new).map(Arc::new));
     }
 
     if let Err(why) = discord_client.start().await {

src/text.rs

@@ -3,12 +3,12 @@
 // since I'm using the same text rendering library, my code is almost one-to-one
 
 use arabic_reshaper::arabic_reshape;
-use imagetext::measure::text_width;
-use imagetext::superfont::SuperFont;
-use imagetext::wrap::{text_wrap, WrapStyle};
-use imagetext::prelude::{scale, BLACK, WHITE, Outline, draw_text_wrapped, TextAlign, stroke};
-use image::{RgbaImage, ExtendedColorType, ImageEncoder};
 use image::codecs::png::PngEncoder;
+use image::{ExtendedColorType, ImageEncoder, RgbaImage};
+use imagetext::measure::text_width;
+use imagetext::prelude::{BLACK, Outline, TextAlign, WHITE, draw_text_wrapped, scale, stroke};
+use imagetext::superfont::SuperFont;
+use imagetext::wrap::{WrapStyle, text_wrap};
 use unicode_bidi::BidiInfo;
 
 enum TextField {
@@ -68,54 +68,89 @@ fn process_text(
     (wrapped_strs, width)
 }
 
-fn draw_info(image: &mut RgbaImage, text: String, text_type: TextField, font: &SuperFont<'static>, font_size: f32, dark_text: bool) -> Result<(), String> {
+fn draw_info(
-	let (lines, width) = process_text(&text, &text_type, font, font_size);
+    image: &mut RgbaImage,
-	let text = lines.join("");
+    text: String,
-	let y = match text_type {
+    text_type: TextField,
-		TextField::Title => 24.0,
+    font: &SuperFont<'static>,
-		TextField::Artist => 73.0,
+    font_size: f32,
-		TextField::Album => 96.0,
+    dark_text: bool,
-	};
+) -> Result<(), String> {
-	let color = if dark_text { &BLACK } else { &WHITE };
+    let (lines, width) = process_text(&text, &text_type, font, font_size);
-	match draw_text_wrapped(
+    let text = lines.join("");
-	     image,
+    let y = match text_type {
-	     color,
+        TextField::Title => 24.0,
-	     Outline::Solid {
+        TextField::Artist => 73.0,
-	     	stroke: &stroke(0.5),
+        TextField::Album => 96.0,
-	     	fill: color,
+    };
-	     },
+    let color = if dark_text { &BLACK } else { &WHITE };
-	     146.0,
+    match draw_text_wrapped(
-	     y,
+        image,
-	     0.0,
+        color,
-	     0.0,
+        Outline::Solid {
-	     width as f32,
+            stroke: &stroke(0.5),
-	     scale(font_size),
+            fill: color,
-	     font,
+        },
-	     &text,
+        146.0,
-	     1.0,
+        y,
-	     TextAlign::Left,
+        0.0,
-	     WrapStyle::Character,
+        0.0,
-	 ) {
+        width as f32,
-	 	Ok(_) => Ok(()),
+        scale(font_size),
-	 	Err(e) => Err(e.to_string()),
+        font,
-	 }
+        &text,
+        1.0,
+        TextAlign::Left,
+        WrapStyle::Character,
+    ) {
+        Ok(_) => Ok(()),
+        Err(e) => Err(e.to_string()),
+    }
 }
 
 pub struct TrackInfo {
-	pub title: String,
+    pub title: String,
-	pub artist: String,
+    pub artist: String,
-	pub album: String,
+    pub album: String,
 }
 
-pub fn fmi_text(width: u32, height: u32, track: TrackInfo, fonts: &(SuperFont<'static>, SuperFont<'static>), font_size: f32, dark_text: bool) -> Result<Vec<u8>, String> {
+pub fn fmi_text(
-	let mut img = RgbaImage::new(width, height);
+    width: u32,
-	draw_info(&mut img, track.title, TextField::Title, &fonts.1.clone(), font_size, dark_text)?;
+    height: u32,
-	draw_info(&mut img, track.artist, TextField::Artist, &fonts.0.clone(), font_size, dark_text)?;
+    track: TrackInfo,
-	draw_info(&mut img, track.album, TextField::Album, &fonts.0.clone(), font_size, dark_text)?;
+    fonts: &(SuperFont<'static>, SuperFont<'static>),
-	let mut blob = Vec::<u8>::new();
+    font_size: f32,
-	let png_encoder = PngEncoder::new(&mut blob);
+    dark_text: bool,
-	match png_encoder.write_image(&img, width, height, ExtendedColorType::Rgba8) {
+) -> Result<Vec<u8>, String> {
-		Ok(()) => Ok(blob),
+    let mut img = RgbaImage::new(width, height);
-		Err(_) => Err("Failed to encode text png".to_string()),
+    draw_info(
-	}
+        &mut img,
+        track.title,
+        TextField::Title,
+        &fonts.1.clone(),
+        font_size,
+        dark_text,
+    )?;
+    draw_info(
+        &mut img,
+        track.artist,
+        TextField::Artist,
+        &fonts.0.clone(),
+        font_size,
+        dark_text,
+    )?;
+    draw_info(
+        &mut img,
+        track.album,
+        TextField::Album,
+        &fonts.0.clone(),
+        font_size,
+        dark_text,
+    )?;
+    let mut blob = Vec::<u8>::new();
+    let png_encoder = PngEncoder::new(&mut blob);
+    match png_encoder.write_image(&img, width, height, ExtendedColorType::Rgba8) {
+        Ok(()) => Ok(blob),
+        Err(_) => Err("Failed to encode text png".to_string()),
+    }
 }