use std::borrow::Cow;
use std::path::PathBuf;

pub const DEFAULT_NAME: &str = "gitbaby-blob-cache";
pub const DEFAULT_MEMORY_CAPACITY_BYTES: usize = 64 * 1024 * 1024;
pub const DEFAULT_DISK_CAPACITY_BYTES: usize = 1024 * 1024 * 1024;

pub const DEFAULT_LFS_NAME: &str = "gitbaby-lfs-cache";
pub const DEFAULT_LFS_DISK_CAPACITY_BYTES: usize = 5 * 1024 * 1024 * 1024;

#[derive(Debug, Clone)]
pub struct CacheConfig {
    pub memory_capacity_bytes: usize,
    pub disk_capacity_bytes: usize,
    pub disk_dir: PathBuf,
    pub name: Cow<'static, str>,
    pub lfs: Option<LfsCacheConfig>,
}

#[derive(Debug, Clone)]
pub struct LfsCacheConfig {
    pub memory_capacity_bytes: usize,
    pub disk_capacity_bytes: usize,
}

impl Default for CacheConfig {
    fn default() -> Self {
        Self {
            memory_capacity_bytes: DEFAULT_MEMORY_CAPACITY_BYTES,
            disk_capacity_bytes: DEFAULT_DISK_CAPACITY_BYTES,
            disk_dir: default_cache_dir(),
            name: Cow::Borrowed(DEFAULT_NAME),
            lfs: None,
        }
    }
}

impl Default for LfsCacheConfig {
    fn default() -> Self {
        Self {
            memory_capacity_bytes: DEFAULT_MEMORY_CAPACITY_BYTES,
            disk_capacity_bytes: DEFAULT_LFS_DISK_CAPACITY_BYTES,
        }
    }
}

impl CacheConfig {
    pub fn from_env() -> Self {
        Self {
            memory_capacity_bytes: env_usize(
                "GITBABY_CACHE_MEM_BYTES",
                DEFAULT_MEMORY_CAPACITY_BYTES,
            ),
            disk_capacity_bytes: env_usize("GITBABY_CACHE_DISK_BYTES", DEFAULT_DISK_CAPACITY_BYTES),
            disk_dir: std::env::var_os("GITBABY_CACHE_DIR")
                .map(PathBuf::from)
                .unwrap_or_else(default_cache_dir),
            name: Cow::Borrowed(DEFAULT_NAME),
            lfs: match env_usize(
                "GITBABY_CACHE_LFS_DISK_BYTES",
                DEFAULT_LFS_DISK_CAPACITY_BYTES,
            ) {
                0 => None,
                disk_capacity_bytes => Some(LfsCacheConfig {
                    memory_capacity_bytes: DEFAULT_MEMORY_CAPACITY_BYTES,
                    disk_capacity_bytes,
                }),
            },
        }
    }
}

fn env_usize(key: &str, default: usize) -> usize {
    std::env::var(key)
        .ok()
        .and_then(|v| v.trim().parse::<usize>().ok())
        .unwrap_or(default)
}

fn default_cache_dir() -> PathBuf {
    if let Some(xdg) = std::env::var_os("XDG_CACHE_HOME") {
        return PathBuf::from(xdg).join("gitbaby");
    }
    if let Some(local) = std::env::var_os("LOCALAPPDATA") {
        return PathBuf::from(local).join("gitbaby");
    }
    if let Some(home) = std::env::var_os("HOME") {
        return PathBuf::from(home).join(".cache").join("gitbaby");
    }
    std::env::temp_dir().join("gitbaby")
}