path: root/src/config.rs

use std::collections::BTreeSet;
use std::sync::LazyLock;
use std::sync::Arc;
use std::future::Future;
use std::pin::Pin;
use std::time::*;

use super::cache::AsyncCache;
use super::deserialize::{GetRecentTracks, GetUserInfo, Track, User};

use reqwest::{Client, StatusCode};
use dotenv::var;
use tokio::sync::RwLock;
use handlebars::{Handlebars, handlebars_helper};
use duration_str as ds;

type CacheFuture<Output> = Pin<Box<(dyn Future<Output = Result<Output, (StatusCode, &'static str)>> + Send + Sync)>>;
type CacheGetter<Output> = fn(&String) -> CacheFuture<Output>;
type Cache<Output>       = Arc<RwLock<AsyncCache<String, Output, CacheGetter<Output>>>>;

type FontFuture = CacheFuture<Arc<str>>;
type FontGetter = CacheGetter<Arc<str>>;
type FontCache  = Cache<Arc<str>>;

type UserFuture = CacheFuture<Arc<(User, Track)>>;
type UserGetter = CacheGetter<Arc<(User, Track)>>;
type UserCache  = Cache<Arc<(User, Track)>>;

static INTERNAL_THEMES: &[(&str, &str)] = &[("plain", include_str!("themes/plain.hbs"))];

pub static STATE: LazyLock<Arc<State>> = LazyLock::new(|| {
  State::new()
});

fn user_getter(username: &String) -> UserFuture {
  let username = urlencoding::encode(username.as_ref()).to_string();
  Box::pin(async move {
    let userreq = STATE.http.get(format!("https://ws.audioscrobbler.com/2.0/?method=user.getInfo&format=json&user={username}&api_key={}", STATE.lastfm_api_key))
      .send().await
      .map_err(|e| {log::error!("Failed to get info for user `{username}`: {e}"); (StatusCode::SERVICE_UNAVAILABLE, "Couldn't connect to last.fm!")})?;
    if userreq.status() == StatusCode::NOT_FOUND { return Err((StatusCode::NOT_FOUND, "User does not exist!")); }

    let userinfo = userreq.json::<GetUserInfo>().await
      .map_err(|e| {log::error!("Couldn't parse user.getInfo for `{username}`: {e}"); (StatusCode::INTERNAL_SERVER_ERROR, "Couldn't parse user.getInfo!")})?.user;

    let tracksreq = STATE.http.get(format!("https://ws.audioscrobbler.com/2.0/?method=user.getRecentTracks&format=json&extended=1&limit=1&user={username}&api_key={}", STATE.lastfm_api_key))
      .send().await
      .map_err(|e| {log::error!("Failed to get tracks for user `{username}`: {e}"); (StatusCode::SERVICE_UNAVAILABLE, "Couldn't connect to last.fm!")})?;
    if tracksreq.status() == StatusCode::NOT_FOUND { return Err((StatusCode::NOT_FOUND, "User does not exist!")); }
    if tracksreq.status() == StatusCode::FORBIDDEN { return Err((StatusCode::FORBIDDEN, "You need to unprivate your song history!")); }

    let tracksinfo = tracksreq.json::<GetRecentTracks>().await
      .map_err(|e| {log::error!("Couldn't parse user.getRecentTracks for `{username}`: {e}"); (StatusCode::INTERNAL_SERVER_ERROR, "Couldn't parse user.getRecentTracks!")})?
      .recenttracks.track.into_iter().next().ok_or((StatusCode::UNPROCESSABLE_ENTITY, "You need to listen to some songs first!"))?;

    Ok(Arc::new((userinfo, tracksinfo)))
  })
}

fn font_getter(fontname: &String) -> FontFuture {
  let fontname = urlencoding::encode(fontname.as_ref()).to_string();
  Box::pin(async move {
    let Some(google_api_key) = STATE.google_api_key.clone()
    else {
      unreachable!();
    };

    let fontreq = STATE.http.get(format!("https://www.googleapis.com/webfonts/v1/webfonts?key={}&family={fontname}", google_api_key))
      .send().await
      .map_err(|e| {log::error!("Failed to get info for font `{fontname}`: {e}"); (StatusCode::SERVICE_UNAVAILABLE, "Couldn't connect to Google Fonts!")})?;
    if fontreq.status() == StatusCode::NOT_FOUND { return Err((StatusCode::NOT_FOUND, "Font does not exist!")); }
    if fontreq.status() == StatusCode::FORBIDDEN {
      log::error!("Invalid Google API key in config!");
      return Err((StatusCode::SERVICE_UNAVAILABLE, "This instance is not configured to support Google Fonts properly, please use a different font."));
    }

    let cssreq = STATE.http.get(format!("https://fonts.googleapis.com/css2?family={fontname}"))
      .send().await
      .map_err(|e| {log::error!("Failed to get CSS for font `{fontname}`: {e}"); (StatusCode::SERVICE_UNAVAILABLE, "Couldn't download font CSS!")})?;

    Ok(cssreq.text().await.unwrap().into())
  })
}


#[derive(Debug)]
enum Whitelist {
  Exclusive{cache: UserCache, whitelist: BTreeSet<String>},
  Open{default_cache: UserCache, whitelist_cache: UserCache, whitelist: BTreeSet<String>}
}
#[derive(Debug)]
pub struct State {
  lastfm_api_key: Arc<str>,
  port: u16,
  default_theme: Arc<str>,
  send_refresh_header: bool,

  http: Client,

  handlebars: Handlebars<'static>,

  google_api_key: Option<Arc<str>>,
  google_fonts_cache: FontCache,

  whitelist: Whitelist,
  default_refresh: Duration,
  whitelist_refresh: Duration,
}

impl State {
  fn new() -> Arc<Self> {
    let duration_from_var = |v: &str, d: u64| -> Duration {var(v).map(|r| ds::parse(&r).expect("bad duration string")).unwrap_or_else(|_| Duration::from_secs(d))};
    let user_cache_from_duration = |d: Duration| -> UserCache {
      Arc::new(RwLock::new(AsyncCache::new(d, user_getter as UserGetter)))
    };
    let default_refresh = duration_from_var("LFME_DEFAULT_REFRESH", 300);
    let whitelist_refresh = duration_from_var("LFME_WHITELIST_REFRESH", 60);
    let default_cache = user_cache_from_duration(default_refresh);
    let whitelist_cache = user_cache_from_duration(whitelist_refresh);
    Arc::new(State {
      lastfm_api_key: var("LFME_LASTFM_API_KEY").expect("last.fm API key must be set").into(),
      port: var("LFME_PORT").map(|p| p.parse().expect("cannot parse as a port number")).unwrap_or(9999),
      default_theme: var("LFME_THEME_DEFAULT").map(Into::into).unwrap_or_else(|_| "plain".into()),
      send_refresh_header: !var("LFME_NO_REFRESH").map(|h| &h == "1").unwrap_or(false),

      http: Client::builder().https_only(true).user_agent(concat!(env!("CARGO_PKG_NAME"), "/", env!("CARGO_PKG_VERSION"))).build().unwrap(),

      handlebars: {
        let mut hb = Handlebars::new();
        handlebars_helper!(url_encode: |s: String| urlencoding::encode(&s));

        hb.register_helper("url-encode", Box::new(url_encode));

        for (key, fulltext) in INTERNAL_THEMES {
          log::info!(target: "lfm::config::theme", "Registering internal theme `{key}`");
          hb.register_template_string(key, fulltext).unwrap();
        }
        hb.set_dev_mode(var("LFME_THEME_DEV").map(|h| &h == "1").unwrap_or(false));

        if let Ok(themes_dir) = var("LFME_THEME_DIR") {
          log::info!(target: "lfm::config::theme", "Registering theme dir `{themes_dir}`");
          hb.register_templates_directory(&var("LFME_THEME_EXT").unwrap_or_else(|_| ".hbs".into()), themes_dir).unwrap();
        }

        hb
      },

      google_api_key: var("LFME_GOOGLE_API_KEY").map(Into::into).ok(),
      google_fonts_cache: Arc::new(RwLock::new(AsyncCache::new(Duration::from_secs(86400), font_getter as FontGetter))),

      whitelist: {
        let load_whitelist = || -> Option<BTreeSet<String>> {
          var("LFME_WHITELIST").ok().map(
            |w| w.split(',').map(|s| s.trim().to_string()).collect()
          )
        };

        match var("LFME_WHITELIST_MODE").map(|m| m.to_ascii_lowercase()).unwrap_or_else(|_| "open".into()).as_str() {
          "open" => {
            Whitelist::Open{default_cache, whitelist_cache, whitelist: load_whitelist().unwrap_or_default()}
          },
          "exclusive" => {
            Whitelist::Exclusive{cache: whitelist_cache, whitelist: load_whitelist().expect("LFME_WHITELIST not set, unable to serve anyone")}
          },
          m => {
            panic!("Bad whitelist mode: `{m}`");
          }
        }
      },
      default_refresh: default_refresh + Duration::from_secs(1),
      whitelist_refresh: whitelist_refresh + Duration::from_secs(1)
    })
  }

  pub fn port(&self) -> u16 { self.port }
  pub fn send_refresh_header(&self) -> bool { self.send_refresh_header }
  pub async fn get_fontinfo(&self, font: &String) -> Result<Arc<str>, (StatusCode, &'static str)> {
    self.google_fonts_cache.write().await.get_owned(font).await
  }
  pub fn has_google_api_key(&self) -> bool { self.google_api_key.is_some() }
  pub async fn get_userinfo(&self, user: &String) -> (Result<Arc<(User, Track)>, (StatusCode, &'static str)>, Duration) {
    match &self.whitelist {
      Whitelist::Open{default_cache, whitelist_cache, whitelist} => {
        if whitelist.contains(user) {
          (whitelist_cache.write().await.get_owned(user).await, self.whitelist_refresh)
        }
        else {
          (default_cache.write().await.get_owned(user).await, self.default_refresh)
        }
      },
      Whitelist::Exclusive{cache, whitelist} => {
        if whitelist.contains(user) {
          (cache.write().await.get_owned(user).await, self.whitelist_refresh)
        }
        else { (Err((StatusCode::FORBIDDEN, "User not in whitelist!")), self.default_refresh) }
      }
    }
  }
  pub fn handlebars(&self) -> &Handlebars { &self.handlebars }
  pub fn default_theme(&self) -> Arc<str> { self.default_theme.clone() }
}