Added override file

.env.example

@@ -1,3 +1,10 @@
 DISCORD_TOKEN=
 LASTFM_API_KEY=
 DATABASE_URL=sqlite:watcat.db
+
+# optional, for spotify support
+RSPOTIFY_CLIENT_ID=
+RSPOTIFY_CLIENT_SECRET=
+
+# optional, to set color cache size. set to 0 to disable
+MAX_CACHE_SIZE=

.gitignore

@@ -2,3 +2,4 @@
 /.env
 /watcat.db*
 /http-cacache
+/overrides.txt

Cargo.lock

@@ -1100,6 +1100,12 @@ dependencies = [
  "foldhash",
 ]
 
+[[package]]
+name = "hashbrown"
+version = "0.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5419bdc4f6a9207fbeba6d11b604d481addf78ecd10c11ad51e76c2f6482748d"
+
 [[package]]
 name = "hashlink"
 version = "0.10.0"
@@ -1570,12 +1576,12 @@ checksum = "d0263a3d970d5c054ed9312c0057b4f3bde9c0b33836d3637361d4a9e6e7a408"
 
 [[package]]
 name = "indexmap"
-version = "2.9.0"
+version = "2.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cea70ddb795996207ad57735b50c5982d8844f38ba9ee5f1aedcfb708a2aa11e"
+checksum = "6717a8d2a5a929a1a2eb43a12812498ed141a0bcfb7e8f7844fbdbe4303bba9f"
 dependencies = [
  "equivalent",
- "hashbrown 0.15.3",
+ "hashbrown 0.16.0",
 ]
 
 [[package]]
@@ -2958,9 +2964,19 @@ dependencies = [
 
 [[package]]
 name = "serde"
-version = "1.0.219"
+version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
 dependencies = [
  "serde_derive",
 ]
@@ -2976,9 +2992,9 @@ dependencies = [
 
 [[package]]
 name = "serde_derive"
-version = "1.0.219"
+version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -4270,7 +4286,7 @@ dependencies = [
 
 [[package]]
 name = "watcat"
-version = "0.5.0"
+version = "0.6.1"
 dependencies = [
  "arabic_reshaper",
  "dotenvy",
@@ -4695,9 +4711,9 @@ checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486"
 
 [[package]]
 name = "winnow"
-version = "0.7.10"
+version = "0.7.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c06928c8748d81b05c9be96aad92e1b6ff01833332f281e8cfca3be4b35fc9ec"
+checksum = "21a0236b59786fed61e2a80582dd500fe61f18b5dca67a4a067d0bc9039339cf"
 dependencies = [
  "memchr",
 ]

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "watcat"
-version = "0.5.0"
+version = "0.6.2"
 edition = "2024"
 
 [dependencies]

README.md

@@ -31,9 +31,11 @@ TODO
 + ~~add art and lastfm url fetching~~
 + ~~add help command~~
 + ~~refactor to combine repeated parts of art, url, and fmi.~~
-+ use macro for commands
++ ~~use macro for commands~~
-+ use Option instead of empty string sentinel value
++ ~~use Option instead of empty string sentinel value~~
-+ add cache for album art colors
++ ~~add cache for album art colors~~
 + ~~add spotify link fetching~~
++ ~~add arbitrary spotify searching~~
++ ~~use static seed for kmeans~~
 + make various parameters user-configurable
 + use tiny-skia instead of magick-rust?

src/main.rs

@@ -2,7 +2,7 @@ extern crate dotenvy;
 extern crate lastfm;
 extern crate reqwest;
 extern crate reqwest_middleware;
-use http_cache_reqwest::{CACacheManager, Cache, CacheMode, HttpCache, HttpCacheOptions};
+use http_cache_reqwest::{CACacheManager, Cache, CacheMode, HttpCache, HttpCacheOptions,};
 
 use serenity::async_trait;
 use serenity::builder::{CreateAttachment, CreateMessage};
@@ -14,8 +14,10 @@ extern crate magick_rust;
 use magick_rust::{
     ColorspaceType, CompositeOperator, FilterType, MagickWand, PixelWand, magick_wand_genesis,
 };
+use magick_rust::bindings::MagickSetSeed;
 
 use std::env;
+use std::collections::HashMap;
 use std::sync::{Arc, Once};
 use tokio::sync::Mutex;
 
@@ -32,6 +34,9 @@ use rspotify::{ClientCredsSpotify, Credentials, clients::BaseClient};
 use imagetext::fontdb::FontDB;
 use imagetext::superfont::SuperFont;
 
+use std::time::SystemTime;
+use std::io::Read;
+
 mod text;
 
 static START: Once = Once::new();
@@ -69,8 +74,9 @@ macro_rules! log {
 macro_rules! handle_magick_result {
     ($a: expr, $b: literal) => {
         match $a {
-            Ok(_) => {
+            Ok(a) => {
                 log!("{} run successfully", stringify!($a));
+                a
             }
             Err(e) => return Reply::Text(format!("Error: {} {}", $b, e)),
         }
@@ -122,12 +128,12 @@ fn validate_color(col: &PixelWand) -> Option<Lab> {
 
 async fn get_track(
     ctx: &Context,
-    arg: &str,
+    arg: Option<&str>,
     id: UserId,
 ) -> Result<lastfm::track::NowPlayingTrack, Reply> {
     let lastfm_user = match arg {
-        "" => get_lastfm_username(ctx, id).await,
+        None => get_lastfm_username(ctx, id).await,
-        _ => Some(arg.to_owned()),
+        Some(user) => Some(user.to_owned()),
     };
     let lastfm_client = match lastfm_user {
         Some(s) => lastfm::Client::<String, String>::from_env(s),
@@ -148,7 +154,7 @@ async fn get_track(
     Ok(track)
 }
 
-async fn art(ctx: &Context, arg: &str, id: UserId) -> Reply {
+async fn art(ctx: &Context, arg: Option<&str>, id: UserId) -> Reply {
     let track = match get_track(ctx, arg, id).await {
         Ok(track) => track,
         Err(e) => return e,
@@ -160,7 +166,7 @@ async fn art(ctx: &Context, arg: &str, id: UserId) -> Reply {
     Reply::Text(track_art.to_owned())
 }
 
-async fn url(ctx: &Context, arg: &str, id: UserId) -> Reply {
+async fn url(ctx: &Context, arg: Option<&str>, id: UserId) -> Reply {
     let track = match get_track(ctx, arg, id).await {
         Ok(track) => track,
         Err(e) => return e,
@@ -168,43 +174,77 @@ async fn url(ctx: &Context, arg: &str, id: UserId) -> Reply {
     Reply::Text(track.url)
 }
 
-async fn spot(ctx: &Context, arg: &str, id: UserId) -> Reply {
+async fn spot(ctx: &Context, arg: Option<&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
+	let spotify_option = data.get_mut::<SpotifyHaver>().expect("Failed to have spotify option");
-        .get_mut::<SpotifyHaver>()
+	if spotify_option.is_none() {
-        .expect("Failed to have spotify option");
+		return Reply::Text("Unable to use Spotify commands: Contact bot Administrator.".to_owned())
-    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_client = spotify_arc_mutex.lock().await;
-    let spotify_arc_mutex = spotify_option.as_mut().unwrap();
+	spotify_client.request_token().await.unwrap();
-    //let spotify_arc_mutex_ref = Arc::clone(&spotify_arc_mutex);
+	let search = spotify_client.search(format!("{} {}", track.name, track.artist.name).as_str(), SearchType::Track, None, None, None, None).await;
-    let spotify_client = spotify_arc_mutex.lock().await;
+	let tracks = match search {
-    let search = spotify_client
+		Ok(SearchResult::Tracks(track_page)) => track_page,
-        .search(
+		Err(e) => return Reply::Text(format!("Failed to get track {e}")),
-            format!(r#"track:"{}" album:"{}" artist:"{}""#, track.name.replace("\"", ""), track.album.replace("\"", ""), track.artist.name.replace("\"", "")).as_str(),
+		_ => return Reply::Text("Spotify search failed".to_owned()),
-            SearchType::Track,
+	};
-            None,
+	match &tracks.items.first().map(|x| x.external_urls.get("spotify")) {
-            None,
+		Some(Some(url)) => Reply::Text(url.to_owned().to_owned()),
-            None,
+		_ => Reply::Text("Unable to get spotify url".to_owned()),
-            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 {
+async fn get_overrides_inner(last_modified: Option<SystemTime>) -> Option<HashMap<String, String>> {
+	let mut file = match std::fs::File::open("overrides.txt") {
+		Ok(a) => a,
+		Err(_) => return None,
+	};
+	let file_stats = match file.metadata() {
+		Ok(a) => a,
+		Err(_) => return None,		
+	};
+	let file_modified_time = match file_stats.modified() {
+		Ok(a) => a,
+		Err(_) => return None,
+	};
+	let reload = match last_modified {
+		None => true,
+		Some(last_modified) => match file_modified_time.duration_since(last_modified) {
+			Err(_) => true,
+			Ok(a) => a != std::time::Duration::default()
+		}
+	};
+	if !reload { return None; }
+	let mut contents = "".to_owned();
+	match file.read_to_string(&mut contents) {
+		Ok(_) => (),
+		Err(_) => return None,
+	};
+	Some(contents.as_str().lines().map(|x| {
+		let mut split = x.split("@");
+		let a: &str = split.next().unwrap_or("").trim();
+		let b: &str  = split.next().unwrap_or("").trim();
+		(a.to_owned(), b.to_owned())
+	}).collect())
+}
+
+async fn get_overrides(ctx: &Context) -> HashMap<String, String> {
+	let data = ctx.data.write().await;
+	let overrides = data.get::<OverridesHaver>().expect("Failed to have overrides");
+	let mut map = overrides.map.lock().await;
+	let new_map = get_overrides_inner(overrides.last_modified).await;
+	if let Some(new_map) = new_map {
+		*map = new_map;
+	}
+	map.clone()
+}
+
+async fn fmi(ctx: &Context, arg: Option<&str>, id: UserId, avatar: Option<String>) -> Reply {
     let track = match get_track(ctx, arg, id).await {
         Ok(track) => track,
         Err(e) => return e,
@@ -214,16 +254,22 @@ async fn fmi(ctx: &Context, arg: &str, id: UserId, avatar: Option<String>) -> Re
         artist: track.artist.name,
         album: track.album,
     };
-    let image_uri = match track.image.extralarge {
+    let original_image_uri = match track.image.extralarge {
         Some(iu) => iu,
         None => return Reply::Text("Error: getting image uri failed".to_owned()),
     };
 
-    let image = match get_image(ctx, image_uri.as_str()).await {
+    let overrides = get_overrides(ctx).await;
-        Ok(i) => i,
+    let image_uri: String = match overrides.get(&format!("{} | {}", track_info.artist, track_info.album)) {
-        Err(e) => return Reply::Text(format!("{e}")),
+    	Some(s) => s,
-    };
+    	None => match overrides.get(&track_info.album) {
+    		Some(s) => s,
+    		None => &original_image_uri,
+    	},
+    }.to_owned();
+
     let mut base_color = PixelWand::new();
+    let mut accent_color = PixelWand::new();
     let mut white = PixelWand::new();
     let main_wand = MagickWand::new();
     let art_wand = MagickWand::new();
@@ -231,67 +277,95 @@ async fn fmi(ctx: &Context, arg: &str, id: UserId, avatar: Option<String>) -> Re
     let mask_wand = MagickWand::new();
     let text_image_wand = MagickWand::new();
 
-    handle_magick_result!(
+	let image = match get_image(ctx, image_uri.as_str()).await {
-        base_color.set_color("#7f7f7f"),
+	    Ok(i) => i,
-        "Failed to set init base color"
+	    Err(e) => return Reply::Text(format!("{e}")),
-    );
+	};
-    handle_magick_result!(
+	handle_magick_result!(
-        art_wand.read_image_blob(image),
+	    art_wand.read_image_blob(image),
-        "Failed to read image from uri"
+	    "Failed to read image from uri"
-    );
+	);
-    handle_magick_result!(
+	handle_magick_result!(
-        art_wand.transform_image_colorspace(ColorspaceType::Lab),
+	    art_wand.transform_image_colorspace(ColorspaceType::Lab),
-        "Failed to set art colorspace"
+	    "Failed to set art colorspace"
-    );
+	);
 	
-    let (art_width, art_height) = (art_wand.get_image_width(), art_wand.get_image_height());
+	handle_magick_result!(
-    handle_magick_result!(
+	    base_color.set_color("#7f7f7f"),
-        art_wand_cluster.new_image(art_width, art_height, &base_color),
+	    "Failed to set init base color"
-        "Failed to init cluster image"
+	);
-    );
-    handle_magick_result!(
-        art_wand_cluster.compose_images(&art_wand, CompositeOperator::SrcOver, true, 0, 0),
-        "Failed to copy onto cluster image"
-    );
-    // least stupid way I could figure out to do this, since it seems that MagickWand::new_from_wand() doesn't work
-    handle_magick_result!(
-        art_wand_cluster.set_image_colorspace(ColorspaceType::Lab),
-        "Failed to set cluster colorspace"
-    );
-    handle_magick_result!(
-        art_wand_cluster.kmeans(10, 200, 0.001),
-        "Failed to run kmeans"
-    );
-    let mut colors = handle_magick_option!(
-        art_wand_cluster.get_image_histogram(),
-        "Failed to get color histogram"
-    );
-    colors.sort_by_cached_key(|color| -(color.get_color_count() as isize));
-    let base_lab = validate_color(&colors[0]).expect("Failed to validate base color");
-    let other_colors = colors
-        .iter()
-        .filter_map(|col| {
-            let testing_color = validate_color(col)?;
-            match testing_color.improved_difference(base_lab) {
-                10.0.. => Some(testing_color),
-                _ => None,
-            }
-        })
-        .collect::<Vec<_>>();
-    let mut accent_color = PixelWand::new();
-    handle_magick_result!(
-        accent_color.set_color("cielab(0.0,0.0,0.0)"),
-        "Failed to init accent color"
-    );
-    if let Some(color) = other_colors.first() {
-        let col = format!("cielab{:?}", color.into_components());
-        handle_magick_result!(
-            accent_color.set_color(col.as_str()),
-            "Failed to set accent color"
-        );
-    }
 	
-    let use_dark_color = match validate_color(&colors[0]) {
+	let color_cache_entry = {
+    	let data = ctx.data.write().await;
+		let color_cache = data.get::<ColorsHaver>().expect("Failed to have colors option");
+		if color_cache.max > 0 {
+			let color_cache_map = color_cache.map.lock().await;
+			color_cache_map.get(image_uri.as_str()).map(|s| s.to_owned())
+		} else {
+			None
+		}
+	};
+		
+
+    let (base_lab, accent_lab) = match color_cache_entry {
+    	Some(value) => value.to_owned(),
+    	None => {
+		    let (art_width, art_height) = (art_wand.get_image_width(), art_wand.get_image_height());
+	    	handle_magick_result!(
+	    	    art_wand_cluster.new_image(art_width, art_height, &base_color),
+	    	    "Failed to init cluster image"
+	    	);
+	    	handle_magick_result!(
+	    	    art_wand_cluster.compose_images(&art_wand, CompositeOperator::SrcOver, true, 0, 0),
+	    	    "Failed to copy onto cluster image"
+	    	);
+	    	// least stupid way I could figure out to do this, since it seems that MagickWand::new_from_wand() doesn't work
+	    	handle_magick_result!(
+	    	    art_wand_cluster.set_image_colorspace(ColorspaceType::Lab),
+	    	    "Failed to set cluster colorspace"
+	    	);
+	    	unsafe { MagickSetSeed(0x5F3759DF); }
+	    	handle_magick_result!(
+	    	    art_wand_cluster.kmeans(10, 200, 0.001),
+	    	    "Failed to run kmeans"
+	    	);
+	    	let mut colors = handle_magick_option!(
+	    	    art_wand_cluster.get_image_histogram(),
+	    	    "Failed to get color histogram"
+	    	);
+	    	colors.sort_by_cached_key(|color| -(color.get_color_count() as isize));
+	    	let base_lab = validate_color(&colors[0]).expect("Failed to validate base color");
+	    	let other_colors = colors
+	    	    .iter()
+	    	    .filter_map(|col| {
+	    	        let testing_color = validate_color(col)?;
+	    	        match testing_color.improved_difference(base_lab) {
+	    	            10.0.. => Some(testing_color),
+	    	            _ => None,
+	    	        }
+	    	    })
+	    	    .collect::<Vec<_>>();
+	    	let mut accent_lab = "cielab(0.0,0.0,0.0)".to_owned();
+			if let Some(color) = other_colors.first() {
+			    accent_lab = format!("cielab{:?}", color.into_components());
+			}
+			let base_lab = handle_magick_result!(colors[0].get_color_as_string(), "Failed to serialize base color");
+	    	let data = ctx.data.write().await;
+			let color_cache = data.get::<ColorsHaver>().expect("Failed to have colors option");
+			let mut color_cache_map = color_cache.map.lock().await;
+			if color_cache_map.keys().len() > color_cache.max {
+				let key: String = color_cache_map.iter().next().unwrap().0.to_owned();
+				color_cache_map.remove(&key);
+			}
+			color_cache_map.insert(image_uri, (base_lab.clone(), accent_lab.clone()));
+	    	(base_lab, accent_lab)
+    	}
+    };
+
+    handle_magick_result!(base_color.set_color(base_lab.as_str()), "Failed to deserialize base color");
+    handle_magick_result!(accent_color.set_color(accent_lab.as_str()), "Failed to deserialize accent color");
+
+    let use_dark_color = match validate_color(&base_color) {
         Some(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);
@@ -372,7 +446,7 @@ async fn fmi(ctx: &Context, arg: &str, id: UserId, avatar: Option<String>) -> Re
     );
 
     handle_magick_result!(
-        main_wand.new_image(image_width as usize, image_height as usize, &colors[0]),
+        main_wand.new_image(image_width as usize, image_height as usize, &base_color),
         "Failed to create wand"
     );
     handle_magick_result!(
@@ -380,13 +454,13 @@ async fn fmi(ctx: &Context, arg: &str, id: UserId, avatar: Option<String>) -> Re
         "Failed to set main colorspace"
     );
     handle_magick_result!(
-        art_wand.adaptive_resize_image(124, 124),
+        art_wand.resize_image(124, 124, FilterType::RobidouxSharp),
         "Failed to resize art"
     );
-    handle_magick_result!(
+    /*handle_magick_result!(
         art_wand_cluster.adaptive_resize_image(124, 124),
         "Failed to resize art_cluster"
-    );
+    );*/
     handle_magick_result!(
         main_wand.compose_images(&art_wand, CompositeOperator::SrcOver, false, 12, 12),
         "Failed to combine art image"
@@ -419,29 +493,44 @@ async fn fmi(ctx: &Context, arg: &str, id: UserId, avatar: Option<String>) -> Re
     Reply::Image(main_wand.write_image_blob("png").unwrap())
 }
 
-fn help(arg: &str) -> Reply {
+async fn text(ctx: &Context, arg: Option<&str>, id: UserId) -> Reply {
+    let track = match get_track(ctx, arg, id).await {
+        Ok(track) => track,
+        Err(e) => return e,
+    };
+    Reply::Text(format!(
+    	"{}\n{}\n{}", 
+        track.name,
+        track.artist.name,
+        track.album,
+    ))
+}
+
+fn help(arg: Option<&str>) -> Reply {
     Reply::Text(format!(
         "```{}```",
         match arg {
-            "" =>
+            None =>
-            	"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"
+            	"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 search <search query>:     searches spotify\n       .k help [command]: displays a help message"
                 .to_owned(),
-            "img" | "fmi" | "fm" | "get" =>
+            Some("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" =>
+            Some("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" =>
+            Some("art") =>
 				"usage: .k art [lastfm user]\nfetches user's now playing track's album art\naliases: .k art, .kart, .ka"
                 .to_owned(),
-            "url" | "link" =>
+            Some("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" =>
+            Some("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"
+            	"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>, .kx, .kspot"
                 .to_owned(),
-            _ => format!("unknown command: {arg}"),
+            Some("search") =>
+            	"usage: .k search <search query>\nsearches spotify with an arbitrary query and returns the first result\naliases: .k search, .ks".to_owned(),
+            Some(cmd) => format!("unknown command: {cmd}"),
         }
     ))
 }
@@ -451,48 +540,88 @@ async fn set(ctx: &Context, arg: &str, id: UserId) -> Reply {
     Reply::Text(format!("set user {arg}"))
 }
 
-//macro_rules! cmd {
+async fn search(ctx: &Context, arg: &str) -> Reply {
-//	(c:lit, abbr:lit, a:ident) => {
+    let mut data = ctx.data.write().await;
-//		(".k", $c, $a) | (".k", $a, $c) | (concat!(".k", $abbr), $ident, "")
+	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 commands: Contact bot Administrator.".to_owned())
+	}
+	let spotify_arc_mutex = spotify_option.as_mut().unwrap();
+	let spotify_client = spotify_arc_mutex.lock().await;
+	spotify_client.request_token().await.unwrap();
+	let search = spotify_client.search(arg, 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.first().map(|x| x.external_urls.get("spotify")) {
+		Some(Some(url)) => Reply::Text(url.to_owned().to_owned()),
+		_ => Reply::Text("Unable to get spotify url".to_owned()),
+	}	
+}
+
+macro_rules! cmd_pattern {
+	($long_cmd:pat, $short_pattern:pat, $arg_name:pat) => {
+		(Some(".k"), Some($long_cmd), $arg_name) | (Some(".k"), $arg_name, Some($long_cmd)) | (Some($short_pattern), $arg_name, None)
+	}
+}
 
 #[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 cmd = cmd_iter.next();
-        let arg1 = cmd_iter.next().unwrap_or("");
+        let arg1 = cmd_iter.next();
-        let arg2 = cmd_iter.next().unwrap_or("");
+        let arg2 = cmd_iter.next();
         let resp = match (cmd, arg1, arg2) {
-            (".set", arg, "") | (".k", "set", arg) | (".kset", arg, "") => {
+            (Some(".k"), Some("help" | "h" | "?"), arg) // skip the ".k <command> help" syntax
-                log!("{} received", msg.content);
+            | (Some(".kh") | Some(".k?"), arg, None) => {
-                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, "")
+        	cmd_pattern!("set", ".kset" | ".set", Some(arg)) =>
-            | (".k", "fm" | "fmi" | "get" | "img", arg) => {
+            /*(".set", arg, "") | (".k", "set", arg) | (".kset", arg, "") =>*/ {
+                log!("{} received", msg.content);
+                Some(set(&ctx, arg, msg.author.id).await)
+            },
+        	cmd_pattern!("art", ".ka" | ".kart", arg) =>
+            /*(".k", "art", arg) | (".k", arg, "art") | (".ka" | ".kart", arg, "") =>*/ {
+                log!("{} received", msg.content);
+                Some(art(&ctx, arg, msg.author.id).await)
+            },
+        	cmd_pattern!("url" | "uri" | "link", ".ku" | ".kl", arg) =>
+            /*(".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)
+            },
+        	cmd_pattern!("text", ".kt", arg) =>
+            /*(".k", "url" | "uri" | "link", arg)
+            | (".k", arg, "url" | "uri" | "link")
+            | (".ku" | ".kl" | ".kurl", arg, "") =>*/ {
+                log!("{} received", msg.content);
+                Some(text(&ctx, arg, msg.author.id).await)
+            },
+        	cmd_pattern!("spot" | "spotify", ".kx", arg) =>
+            /*(".k", "spot" | "spotify", arg)
+            | (".k", arg, "spot" | "spotify")
+            | (".ks" | ".kspot", arg, "") =>*/ {
+                log!("{} received", msg.content);
+                Some(spot(&ctx, arg, msg.author.id).await)
+            },
+        	(Some(".ks"), Some(_), _) => {
+                log!("{} received", msg.content);
+        		Some(search(&ctx, &msg.content[4..]).await)
+        	},
+        	(Some(".k"), Some("search"), Some(_)) => {
+                log!("{} received", msg.content);
+        		Some(search(&ctx, &msg.content[10..]).await)
+        	},
+        	cmd_pattern!("fm" | "fmi" | "get" | "img", ".fmi" | ".k" | ".kf" | ".ki" | ".kfmi", 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)
             }
@@ -535,6 +664,24 @@ impl TypeMapKey for SpotifyHaver {
     type Value = Option<Arc<Mutex<ClientCredsSpotify>>>;
 }
 
+struct ColorCache {
+	map: Arc<Mutex<HashMap<String, (String, String)>>>,
+	max: usize,
+}
+struct ColorsHaver;
+impl TypeMapKey for ColorsHaver {
+	type Value = ColorCache;
+}
+
+struct Overrides {
+	map: Arc<Mutex<HashMap<String, String>>>,
+	last_modified: Option<SystemTime>,
+}
+struct OverridesHaver;
+impl TypeMapKey for OverridesHaver {
+	type Value = Overrides;
+}
+
 struct DBResponse {
     lastfm_username: String,
 }
@@ -568,7 +715,7 @@ async fn get_lastfm_username(ctx: &Context, id: UserId) -> Option<String> {
 
 async fn set_lastfm_username(ctx: &Context, id: UserId, user: String) {
     log!("set db user {} {}", id, user);
-    let data = ctx.data.write().await;
+    let data = ctx.data.read().await;
     let pool = data
         .get::<PoolHaver>()
         .expect("Failed to get pool container");
@@ -587,8 +734,8 @@ 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);
+	log!("get {}", url);
-    let data = ctx.data.write().await;
+    let data = ctx.data.read().await;
     let http = data.get::<HttpHaver>().expect("Failed to get http client");
     match http.get(url).send().await {
         Ok(resp) => {
@@ -668,6 +815,16 @@ async fn main() {
         let _ = &spotify_client.request_token().await.unwrap();
     }
 
+    let colors_cache = ColorCache {
+    	map: Arc::new(Mutex::new(HashMap::new())),
+    	max: env::var("MAX_CACHE_SIZE").unwrap_or("".to_owned()).parse::<usize>().unwrap_or(1000000),
+	};
+
+	let overrides = Overrides {
+		map: Arc::new(Mutex::new(HashMap::new())),
+		last_modified: None,
+	};
+
     let mut discord_client = Client::builder(&token, intents)
         .event_handler(Handler)
         .await
@@ -679,6 +836,8 @@ async fn main() {
         data.insert::<HttpHaver>(http);
         data.insert::<FontsHaver>((regular_fonts, bold_fonts));
         data.insert::<SpotifyHaver>(spotify.map(Mutex::new).map(Arc::new));
+        data.insert::<ColorsHaver>(colors_cache);
+        data.insert::<OverridesHaver>(overrides);
     }
 
     if let Err(why) = discord_client.start().await {