lb-discord-rpc/src/main.rs

mod lb;

use core::time;
use std::{collections::HashMap, env, error::Error, thread};

use discord_rpc_client::models::ActivityAssets;
use dotenv::dotenv;
use env_logger::Env;
use lb::listenbrainz::Client;
use log::debug;

fn main() -> Result<(), Box<dyn Error>> {
    dotenv().ok();
    if cfg!(debug_assertions) {
        env_logger::init_from_env(Env::new().default_filter_or("debug"));
    } else {
        env_logger::init_from_env(Env::new().default_filter_or("info"));
    }

    let lb = Client::new();
    let mut drpc = discord_rpc_client::Client::new(env::var("DISCORD_CLIENT_ID")?.parse()?);
    drpc.start();

    let mut cover_cache: HashMap<String, String> = HashMap::new();

    loop {
        // TODO: Error handling lol
        let np = lb.now_playing(&env::var("LB_USER")?)?;
        let listen = np.listens.first();

        if listen.is_none() {
            drpc.clear_activity().unwrap();
            thread::sleep(time::Duration::from_secs(15));
            continue;
        }

        let metadata = &listen.unwrap().track_metadata;

        let track = metadata.track_name.clone();
        let artist = metadata.artist_name.clone();

        let hash_key = format!("{} - {}", &track, &artist);
        let cover_art = if cover_cache.contains_key(&hash_key) {
            debug!("Got cover art from cache");
            Ok(cover_cache.get(&hash_key).unwrap().clone())
        } else {
            let url = lb.cover_art(&track, &artist);

            match url {
                Ok(a) => {
                    cover_cache.insert(hash_key, a.clone());
                    Ok(a)
                },
                Err(e) => {
                    Err(e)
                },
            }
        };

        drpc.set_activity(|act| {
            let mut t = act.state(artist.clone()).details(track.clone());

            match cover_art {
                Ok(url) => {
                    t = t.assets(|_| {
                        ActivityAssets::new()
                            .large_image(url)
                            .large_text(format!("{} - {}", &track, &artist))
                    })
                },
                Err(e) => {
                    debug!("Error fetching cover_art: {}", e);
                },
            }

            t
        }).unwrap();

        thread::sleep(time::Duration::from_secs(15));
    }
}