use std::sync::Arc;

use cache::redis::RedisCache;
use db::conn::Db;
use jwt::{HasJwtState, JwtState};
use storage::StorageRepository;

use crate::config::{SharedUserConfig, UserConfig};

pub mod avatar;
pub mod deletion;
pub mod devices;
pub mod emails;
pub mod notifications;
pub mod preferences;
pub mod profile;
pub mod security;
pub mod sessions;
pub mod social;
pub mod suspensions;

#[derive(Clone)]
pub struct UserService {
    pub db: Db,
    pub kv: Arc<RedisCache>,
    pub config: SharedUserConfig,
    pub jwt: JwtState,
    pub storage: Arc<dyn StorageRepository>,
}

impl UserService {
    pub fn new(
        db: Db,
        kv: Arc<RedisCache>,
        jwt: JwtState,
        storage: Arc<dyn StorageRepository>,
    ) -> Self {
        Self {
            db,
            kv,
            config: Arc::new(UserConfig::default()),
            jwt,
            storage,
        }
    }

    pub fn with_config(mut self, config: SharedUserConfig) -> Self {
        self.config = config;
        self
    }
}

impl HasJwtState for UserService {
    fn jwt_state(&self) -> &JwtState {
        &self.jwt
    }

    fn access_blacklist(&self) -> Option<Arc<rate_limit::AccessTokenBlacklist>> {
        Some(Arc::new(rate_limit::AccessTokenBlacklist::new(self.kv.clone())))
    }
}

impl rate_limit::RateLimitProvider for UserService {
    fn rate_limit_kv(&self) -> Arc<RedisCache> {
        self.kv.clone()
    }

    fn rate_limit_settings(&self) -> Arc<rate_limit::RateLimitConfig> {
        Arc::new(rate_limit::RateLimitConfig::default())
    }
}