use std::time::Duration;

use chrono::{DateTime, Utc};
use sea_orm::{ColumnTrait, EntityTrait, QueryFilter};
use serde::{Deserialize, Serialize};
use utoipa::ToSchema;

use crate::AuthService;
use crate::errors::{AuthError, AuthResult};
use crate::models::users::users;
use crate::session::Session;

#[derive(Clone, Debug, Deserialize, PartialEq, Eq, Serialize, ToSchema)]
pub struct MeResponse {
    pub user_id: i64,
    pub username: String,
    pub displayname: Option<String>,
    pub email: String,
    pub is_admin: bool,
    pub avatar_url: Option<String>,
    pub email_verified_at: Option<DateTime<Utc>>,
    pub created_at: DateTime<Utc>,
    pub version: i32,
}

impl From<users::Model> for MeResponse {
    fn from(user: users::Model) -> Self {
        Self {
            user_id: user.id,
            username: user.username,
            displayname: user.displayname,
            email: user.email,
            is_admin: user.is_admin,
            avatar_url: None,
            email_verified_at: user.email_verified_at,
            created_at: user.created_at,
            version: user.version,
        }
    }
}

pub const ME_CACHE_TTL_SECS: u64 = 300;
const ME_COUNT_TTL_SECS: u64 = 600;
const ME_REFRESH_EVERY: i64 = 5;

pub fn me_cache_keys(user_id: i64) -> (String, String) {
    (
        format!("auth:me:{user_id}"),
        format!("auth:me:count:{user_id}"),
    )
}

pub async fn invalidate_me_cache(cache: &crate::cache::Cache, user_id: i64) {
    let (cache_key, count_key) = me_cache_keys(user_id);
    let dropped = async {
        cache.delete(&cache_key).await?;
        cache.delete(&count_key).await?;
        Ok::<(), crate::cache::CacheError>(())
    }
    .await;
    if let Err(error) = dropped {
        tracing::warn!(%error, user_id, "failed to drop the me cache");
    }
}

impl AuthService {
    #[tracing::instrument(skip_all, fields(request_id = %_request_id, client_ip = ?session.client_ip().ok().flatten()))]
    pub async fn me(&self, session: Session, _request_id: String) -> AuthResult<MeResponse> {
        let user_id = self
            .accounts
            .require_session(&session, Some(_request_id.as_str()))
            .await?;
        self.me_for_user(user_id).await
    }

    pub(crate) async fn me_for_user(&self, user_id: i64) -> AuthResult<MeResponse> {
        let (cache_key, count_key) = me_cache_keys(user_id);

        let count = self.cache().incr(&count_key).await?;
        if count == 1 {
            let _ = self
                .cache()
                .expire(&count_key, Duration::from_secs(ME_COUNT_TTL_SECS))
                .await;
        }
        if count % ME_REFRESH_EVERY != 0
            && let Some(cached) = self.cache().get_json::<MeResponse>(&cache_key).await?
        {
            return Ok(cached);
        }

        let user = users::Entity::find_by_id(user_id)
            .filter(users::Column::DeletedAt.is_null())
            .one(self.db().read())
            .await?
            .ok_or(AuthError::Unauthenticated)?;

        let me = MeResponse::from(user);

        let _ = self
            .cache()
            .set_json_ex(&cache_key, &me, Duration::from_secs(ME_CACHE_TTL_SECS))
            .await;

        Ok(me)
    }
}