use std::collections::{HashMap, HashSet};
use std::error::Error;
use std::sync::LazyLock;
use std::sync::Arc;
use std::future::Future;
use std::pin::Pin;
use std::fs;
use std::time::*;
use duration_str as ds;

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

use reqwest::Client;
use dotenv::var;
use tokio::sync::RwLock;

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

fn getter(username: &String) -> Pin<Box<dyn Future<Output = Result<(User, Track), &'static str>>>> {
    Box::pin(async{Err("nope")})
}

type Cache = Arc<RwLock<AsyncCache<String, (User, Track), fn(&String) -> Pin<Box<dyn Future<Output = Result<(User, Track), &'static str>>>>>>>;
#[derive(Debug)]
enum Whitelist {
    Exclusive{cache: Cache, whitelist: HashSet<String>},
    Open{default_cache: Cache, whitelist_cache: Cache, whitelist: HashSet<String>}
}
#[derive(Debug)]
pub struct State {
    api_key: Arc<str>,
    whitelist: Whitelist,
    port: u16,
    custom_themes: HashMap<String, Arc<str>>,
    send_refresh_header: bool
}

impl State {
    fn new() -> Arc<Self> {
        Arc::new(State {
            api_key: var("LFME_API_KEY").expect("API key must be set").into(),
            port: var("LFME_PORT").map(|p| p.parse().expect("cannot parse as a port number")).unwrap_or(9999),
            send_refresh_header: var("LFME_SET_HEADER").map(|h| &h == "1").unwrap_or(false),
            
            custom_themes: {
                if let Ok(themes_dir) = var("LFME_THEMES_DIR") {
                    fs::read_dir(themes_dir).expect("error reading LFME_THEMES_DIR")
                        .map(|a| a.expect("error reading LFME_THEMES_DIR"))
                        .filter_map(|a| {
                            let path = a.path();
                            if fs::metadata(&path).map(|m| m.is_file()).unwrap_or(false) &&
                                path.extension() == Some("css".as_ref()) {
                                    Some((path.file_stem().unwrap().to_str().expect("bad filename").to_string(), fs::read_to_string(&path).expect("couldn't read theme CSS").into()))
                                }
                            else { None }
                        })
                        .collect()
                }
                else { HashMap::new() }
            },
            
            whitelist: {
                let cache_from_var = |v: &str, d: u64| -> Cache {
                    let refresh = var(v).map(|r| ds::parse(&r).expect("bad duration string")).unwrap_or_else(|_| Duration::from_secs(d));
                    Arc::new(RwLock::new(AsyncCache::new(refresh, getter as _)))
                };
                let default_cache = || cache_from_var("LFME_DEFAULT_REFRESH", 300);
                let whitelist_cache = || cache_from_var("LFME_WHITELIST_REFRESH", 60);
                
                let load_whitelist = || -> Option<HashSet<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: default_cache(), whitelist_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}`");
                    }
                }
            }
        })
    }
    
    pub fn api_key(&self) -> Arc<str> { self.api_key.clone() }
    pub fn port(&self) -> u16 { self.port }
}