use async_session::{Result, Session, SessionStore};
use async_trait::async_trait;
use shared_svc::cache::{CacheKey, RedisManager, redis::AsyncCommands};
use sqlx::PgPool;
use tracing::{debug, instrument};

#[derive(Debug, Clone)]
pub struct AuthService {
    cache: RedisManager,
    database: PgPool,
}

impl AuthService {
    pub fn new(cache: &RedisManager, database: &PgPool) -> Self {
        Self {
            cache: cache.clone(),
            database: database.clone(),
        }
    }
}

#[async_trait]
impl SessionStore for AuthService {
    #[doc = " Get a session from the storage backend."]
    #[doc = ""]
    #[doc = " The input is expected to be the value of an identifying"]
    #[doc = " cookie. This will then be parsed by the session middleware"]
    #[doc = " into a session if possible"]
    #[instrument(skip(self))]
    async fn load_session(&self, cookie_value: String) -> Result<Option<Session>> {
        todo!()
    }

    #[doc = " Store a session on the storage backend."]
    #[doc = ""]
    #[doc = " The return value is the value of the cookie to store for the"]
    #[doc = " user that represents this session"]
    #[instrument(err(Debug), skip(self, session), fields(id = session.id()))]
    async fn store_session(&self, session: Session) -> Result<Option<String>> {
        debug!("storing session");
        let mut client = self.cache.get().await?;
        let bytes = serde_json::to_vec(&session)?;
        client
            .set_ex::<_, _, ()>(CacheKey::Session(session.id()), bytes, 3600)
            .await?;
        Ok(session.into_cookie_value())
    }

    #[doc = " Remove a session from the session store"]
    #[instrument(err(Debug), skip(self, session), fields(id = session.id()))]
    async fn destroy_session(&self, session: Session) -> Result {
        debug!("destroying session");
        let mut client = self.cache.get().await?;
        client.del::<_, ()>(CacheKey::Session(session.id())).await?;
        Ok(())
    }

    #[doc = " Empties the entire store, destroying all sessions"]
    #[instrument(skip(self))]
    async fn clear_store(&self) -> Result {
        debug!("clearing store");
        let mut client = self.cache.get().await?;
        client.del::<_, ()>(CacheKey::Session("").key()).await?;
        Ok(())
    }
}