extern crate dotenvy;
extern crate lastfm;
extern crate reqwest;
extern crate reqwest_middleware;
use http_cache_reqwest::{CACacheManager, Cache, CacheMode, HttpCache, HttpCacheOptions,};

use serenity::async_trait;
use serenity::builder::{CreateAttachment, CreateMessage};
use serenity::model::channel::Message;
use serenity::model::id::UserId;
use serenity::prelude::*;

extern crate magick_rust;
use magick_rust::{
    ColorspaceType, CompositeOperator, FilterType, MagickWand, PixelWand, magick_wand_genesis,
};

use std::env;
use std::collections::HashMap;
use std::sync::{Arc, Once};
use tokio::sync::Mutex;

use palette::color_difference::ImprovedCiede2000;
use palette::lab::Lab;
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;

mod text;

static START: Once = Once::new();

struct Handler;

enum Reply {
    Image(Vec<u8>),
    Text(String),
}

macro_rules! now {
    () => {
        std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_secs_f32() as usize
    };
}

macro_rules! log {
	($a:expr) => {
		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_owned()) == "1" {
			println!(concat!("debug: {} ", $a), now!(), $($b),+)
		}
	};
}

macro_rules! handle_magick_result {
    ($a: expr, $b: literal) => {
        match $a {
            Ok(a) => {
                log!("{} run successfully", stringify!($a));
                a
            }
            Err(e) => return Reply::Text(format!("Error: {} {}", $b, e)),
        }
    };
}

macro_rules! handle_magick_option {
    ($a: expr, $b: literal) => {
        match $a {
            Some(res) => res,
            None => return Reply::Text($b.to_owned()),
        }
    };
}

// this function is almost assuredly the least idiomatic rust code I will ever write.
// but until I know what the "correct" way is, it'll have to do
fn parse_cielab(s: String) -> Result<(f32, f32, f32), &'static str> {
    if s.len() < 13 || &s[0..7] != "cielab(" || s.chars().nth(s.len() - 1).unwrap() != ')' {
        return Err("Error parsing cielab string");
    }
    let vals = s[7..(s.len() - 1)]
        .split(",")
        .map(|x| match x.parse() {
            Ok(f) => f,
            Err(_) => f32::NAN,
        })
        .collect::<Vec<f32>>();
    if vals.iter().any(|x| x.is_nan()) {
        return Err("Error parsing cielab string");
    }
    match &vals[..] {
        &[a, b, c] => Ok((a, b, c)),
        _ => Err("Error parsing cielab string"),
    }
}

fn validate_color(col: &PixelWand) -> Option<Lab> {
    let color_str = match col.get_color_as_string() {
        Ok(s) => s,
        Err(_) => return None,
    };
    let color_raw = match parse_cielab(color_str) {
        Ok(f) => f,
        Err(_) => return None,
    };
    Some(Lab::<D65>::from_components(color_raw))
}

async fn get_track(
    ctx: &Context,
    arg: Option<&str>,
    id: UserId,
) -> Result<lastfm::track::NowPlayingTrack, Reply> {
    let lastfm_user = match arg {
        None => get_lastfm_username(ctx, id).await,
        Some(user) => Some(user.to_owned()),
    };
    let lastfm_client = match lastfm_user {
        Some(s) => lastfm::Client::<String, String>::from_env(s),
        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 Err(Reply::Text(format!(
                "Error: grabbing last.fm user data failed {e}"
            )));
        }
    };
    let track = match now_playing {
        Some(track) => track,
        None => return Err(Reply::Text("Nothing playing.".to_owned())),
    };
    Ok(track)
}

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,
    };
    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: Option<&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: 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.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(format!("{} {}", track.name, track.artist.name).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.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()),
	}
}

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,
    };
    let track_info = text::TrackInfo {
        title: track.name,
        artist: track.artist.name,
        album: track.album,
    };
    let image_uri = match track.image.extralarge {
        Some(iu) => iu,
        None => return Reply::Text("Error: getting image uri failed".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();
    let mut art_wand_cluster = MagickWand::new();
    let mask_wand = MagickWand::new();
    let text_image_wand = MagickWand::new();

	let image = match get_image(ctx, image_uri.as_str()).await {
	    Ok(i) => i,
	    Err(e) => return Reply::Text(format!("{e}")),
	};
	handle_magick_result!(
	    art_wand.read_image_blob(image),
	    "Failed to read image from uri"
	);
	handle_magick_result!(
	    art_wand.transform_image_colorspace(ColorspaceType::Lab),
	    "Failed to set art colorspace"
	);
	
	handle_magick_result!(
	    base_color.set_color("#7f7f7f"),
	    "Failed to set init base color"
	);
	
	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"
	    	);
	    	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);
            black_delta_e > white_delta_e
        }
        _ => false,
    };

    handle_magick_result!(white.set_color("#ffffff"), "Failed to init white");
    handle_magick_result!(
        mask_wand.read_image_blob(include_bytes!("accent_mask.png")),
        "Failed to load mask"
    );
    handle_magick_result!(
        mask_wand.opaque_paint_image(&white, &accent_color, 0.0, false),
        "Failed to paint accent mask"
    );

    let avatar_wand = MagickWand::new();
    match avatar {
        Some(avatar_uri) => {
            if let Ok(avatar) = get_image(ctx, avatar_uri.as_str()).await {
                handle_magick_result!(
                    avatar_wand.read_image_blob(avatar),
                    "Failed to load user avatar"
                );
            } else {
                handle_magick_result!(
                    avatar_wand.new_image(100, 100, &white),
                    "Failed to load dummy avatar"
                );
            }
        }
        None => handle_magick_result!(
            avatar_wand.new_image(100, 100, &white),
            "Failed to load dummy avatar"
        ),
    }
    let avatar_mask_wand = MagickWand::new();
    handle_magick_result!(
        avatar_mask_wand.read_image_blob(include_bytes!("avatar_mask.png")),
        "Failed to load avatar mask"
    );
    handle_magick_result!(
        avatar_wand.compose_images(&avatar_mask_wand, CompositeOperator::CopyAlpha, false, 0, 0),
        "Failed to mask avatar"
    );
    handle_magick_result!(
        avatar_wand.resize_image(64, 64, FilterType::RobidouxSharp),
        "Failed to resize avatar"
    );
    handle_magick_result!(
        avatar_wand.transform_image_colorspace(ColorspaceType::Lab),
        "Failed to set avatar colorspace"
    );

    let (image_width, image_height) = (548, 147);
    let data = ctx.data.write().await;
    let fonts = data.get::<FontsHaver>().expect("Failed to load fonts");
    let text_image_blob = match text::fmi_text(
        image_width,
        image_height,
        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.transform_image_colorspace(ColorspaceType::Lab),
        "Failed to set avatar colorspace"
    );

    handle_magick_result!(
        main_wand.new_image(image_width as usize, image_height as usize, &base_color),
        "Failed to create wand"
    );
    handle_magick_result!(
        main_wand.transform_image_colorspace(ColorspaceType::Lab),
        "Failed to set main colorspace"
    );
    handle_magick_result!(
        art_wand.adaptive_resize_image(124, 124),
        "Failed to resize art"
    );
    /*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"
    );
    handle_magick_result!(
        main_wand.compose_images(&mask_wand, CompositeOperator::SrcOver, false, 401, 0),
        "Failed to combine mask"
    );
    #[cfg(debug_assertions)]
    if env::var("DEBUG_IMAGE").unwrap_or("0".to_owned()) == "1" {
        handle_magick_result!(
            main_wand.compose_images(
                &art_wand_cluster,
                CompositeOperator::SrcOver,
                false,
                160,
                12
            ),
            "Failed to combine debug image"
        );
    }
    handle_magick_result!(
        main_wand.compose_images(&text_image_wand, CompositeOperator::SrcOver, false, 0, 0),
        "Failed to combine mask"
    );
    handle_magick_result!(
        main_wand.compose_images(&avatar_wand, CompositeOperator::SrcOver, false, 473, 73),
        "Failed to combine avatar image"
    );
    Reply::Image(main_wand.write_image_blob("png").unwrap())
}

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 search <search query>:     searches spotify\n       .k help [command]: displays a help message"
                .to_owned(),
            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(),
            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(),
            Some("art") =>
				"usage: .k art [lastfm user]\nfetches user's now playing track's album art\naliases: .k art, .kart, .ka"
                .to_owned(),
            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(),
            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>, .kx, .kspot"
                .to_owned(),
            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}"),
        }
    ))
}

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}"))
}

async fn search(ctx: &Context, arg: &str) -> Reply {
    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 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();
        let arg1 = cmd_iter.next();
        let arg2 = cmd_iter.next();
        let resp = match (cmd, arg1, arg2) {
            (Some(".k"), Some("help" | "h" | "?"), arg) // skip the ".k <command> help" syntax
            | (Some(".kh") | Some(".k?"), arg, None) => {
                log!("{} received", msg.content);
                Some(help(arg))
            }
        	cmd_pattern!("set", ".kset" | ".set", Some(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!("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)
            }
            _ => None,
        };
        if let Some(reply) = resp {
            let m = match reply {
                Reply::Image(img) => {
                    let file = CreateAttachment::bytes(img, "fmi.png");
                    CreateMessage::new().add_file(file)
                }
                Reply::Text(txt) => CreateMessage::new().content(txt),
            };

            let message = msg.channel_id.send_message(&ctx.http, m).await;
            if let Err(why) = message {
                println!("Error sending message: {why:?}");
            }
        }
    }
}

struct HttpHaver;
impl TypeMapKey for HttpHaver {
    type Value = reqwest_middleware::ClientWithMiddleware;
}

struct PoolHaver;
impl TypeMapKey for PoolHaver {
    type Value = SqlitePool;
}

struct FontsHaver;
impl TypeMapKey for FontsHaver {
    type Value = (SuperFont<'static>, SuperFont<'static>);
}

struct SpotifyHaver;
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 DBResponse {
    lastfm_username: String,
}

async fn get_lastfm_username(ctx: &Context, id: UserId) -> Option<String> {
    log!("get db user {}", id);
    let data = ctx.data.write().await;
    let pool = data
        .get::<PoolHaver>()
        .expect("Failed to get pool container");
    let id = i64::from(id);
    let resp = sqlx::query_as!(
        DBResponse,
        r#"
			SELECT lastfm_username
			FROM users
			WHERE discord_userid = ?1
		"#,
        id
    )
    .fetch_one(pool)
    .await;
    match resp {
        Ok(r) => {
            log!("got user {}", r.lastfm_username);
            Some(r.lastfm_username)
        }
        Err(_) => None,
    }
}

async fn set_lastfm_username(ctx: &Context, id: UserId, user: String) {
    log!("set db user {} {}", id, user);
    let data = ctx.data.read().await;
    let pool = data
        .get::<PoolHaver>()
        .expect("Failed to get pool container");
    let id = i64::from(id);
    sqlx::query!(
        r#"
			INSERT INTO users
			VALUES (?1, ?2)
		"#,
        id,
        user
    )
    .execute(pool)
    .await
    .expect("Failed to insert");
}

async fn get_image(ctx: &Context, url: &str) -> Result<Vec<u8>, reqwest_middleware::Error> {
	log!("get {}", url);
    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) => {
            log!("response received");
            Ok(resp
                .bytes()
                .await
                .expect("Unable to resolve bytes")
                .to_vec())
        }
        Err(e) => Err(e),
    }
}

#[tokio::main]
async fn main() {
    START.call_once(|| {
        dotenvy::dotenv().expect("Failed to load .env");
        magick_wand_genesis();
    });

    let db_url = env::var("DATABASE_URL").expect("Failed to load DATABASE_URL");
    let pool = SqlitePool::connect(&db_url)
        .await
        .expect("Failed to load db");

    let token = env::var("DISCORD_TOKEN").expect("Failed to load DISCORD_TOKEN");
    // Set gateway intents, which decides what events the bot will be notified about
    let intents = GatewayIntents::GUILD_MESSAGES
        | GatewayIntents::DIRECT_MESSAGES
        | GatewayIntents::MESSAGE_CONTENT;

    let http = reqwest_middleware::ClientBuilder::new(reqwest::Client::new())
        .with(Cache(HttpCache {
            mode: CacheMode::Default,
            manager: CACacheManager::default(),
            options: HttpCacheOptions::default(),
        }))
        .build();

    FontDB::load_from_dir("fonts"); //singlet instance??? wha?????
    let regular_fonts = FontDB::query(
        "
    	NotoSans-Regular
    	NotoSansHK-Regular
    	NotoSansJP-Regular
    	NotoSansKR-Regular
    	NotoSansSC-Regular
    	NotoSansTC-Regular
    	NotoSansArabic-Regular
    	Heebo-Regular
    	NotoEmoji-Regular
    	Symbola
    	Unifont
    ",
    )
    .expect("Failed to load regular fonts");
    let bold_fonts = FontDB::query(
        "
    	NotoSans-SemiBold
    	NotoSansJP-Medium
    	NotoSansKR-Medium
    	NotoSansSC-Medium
    	NotoSansTC-Medium
    	NotoSansArabic-SemiBold
    	Heebo-SemiBold
    	NotoEmoji-Medium
    	Symbola
    	Unifont
    ",
    )
    .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 colors_cache: ColorCache = ColorCache {
    	map: Arc::new(Mutex::new(HashMap::new())),
    	max: env::var("MAX_CACHE_SIZE").unwrap_or("".to_owned()).parse::<usize>().unwrap_or(1000000),
	};

    let mut discord_client = Client::builder(&token, intents)
        .event_handler(Handler)
        .await
        .expect("Err creating Discord client");

    {
        let mut data = discord_client.data.write().await;
        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));
        data.insert::<ColorsHaver>(colors_cache);
    }

    if let Err(why) = discord_client.start().await {
        println!("Client error: {why:?}");
    }
}
