aurabase 0.1.1

use crate::client::{AuraClient, RequestBody};
use crate::error::AuraError;
use crate::types::*;

/// Clés de `query_params` réellement transmises au fournisseur OAuth.
///
/// Miroir EXACT d'`OAUTH_FORWARDABLE_PARAMS` (`services/aura-auth/src/handlers/oauth.rs`) :
/// les paramètres d'EXPÉRIENCE de connexion d'OpenID Connect Core §3.1.2.1 et leurs équivalents
/// Google. La garde qui protège est celle du backend — l'endpoint de démarrage est public et
/// appelable sans SDK ; cette liste ne sert qu'à échouer AVANT la redirection pleine page. Le
/// test de parité `tests/oauth_query_params.rs` interdit qu'elles divergent.
pub const OAUTH_FORWARDABLE_QUERY_PARAMS: [&str; 10] = [
    "access_type",
    "acr_values",
    "claims_locales",
    "display",
    "hd",
    "include_granted_scopes",
    "login_hint",
    "max_age",
    "prompt",
    "ui_locales",
];

/// Paramètres que `sign_in_with_oauth` construit lui-même. Les laisser passer par
/// `query_params` les ferait apparaître DEUX FOIS dans la query (la liste de paires est un
/// `Vec`, pas une map) — et le backend refuse explicitement une clé répétée.
pub const OAUTH_SDK_OWNED_QUERY_PARAMS: [&str; 6] = [
    "code_challenge",
    "code_challenge_method",
    "project_id",
    "redirect_to",
    "redirect_uri",
    "scopes",
];

pub struct AuthService {
    client: AuraClient,
}

impl AuthService {
    pub fn new(client: AuraClient) -> Self {
        Self { client }
    }

    fn prefix(&self) -> String {
        "/v1/auth".to_string()
    }

    // -- Événements ----------------------------------------------------------

    /// S'abonne aux changements d'état d'authentification.
    pub fn on_auth_state_change(
        &self,
    ) -> tokio::sync::broadcast::Receiver<(Option<String>, Option<User>)> {
        self.client.auth_store().subscribe()
    }

    // -- Inscription / Connexion ---------------------------------------------

    pub async fn sign_up(
        &self,
        req: SignUpRequest,
    ) -> Result<AuraResponse<LoginResponse>, AuraError> {
        let res = self
            .client
            .request::<LoginResponse>(
                reqwest::Method::POST,
                &format!("{}/register", self.prefix()),
                RequestBody::Json(serde_json::to_value(&req).unwrap_or_default()),
            )
            .await?;

        if let Some(LoginResponse::TokenPair(ref tp)) = res.data {
            self.client.auth_store().save(
                tp.access_token.clone(),
                tp.refresh_token.clone(),
                tp.user.clone(),
            );
        }

        Ok(res)
    }

    pub async fn sign_in_with_password(
        &self,
        req: SignInRequest,
    ) -> Result<AuraResponse<LoginResponse>, AuraError> {
        let res = self
            .client
            .request::<LoginResponse>(
                reqwest::Method::POST,
                &format!("{}/login", self.prefix()),
                RequestBody::Json(serde_json::to_value(&req).unwrap_or_default()),
            )
            .await?;

        if let Some(LoginResponse::TokenPair(ref tp)) = res.data {
            self.client.auth_store().save(
                tp.access_token.clone(),
                tp.refresh_token.clone(),
                tp.user.clone(),
            );
        }

        Ok(res)
    }

    /// URL de démarrage du flux OAuth.
    ///
    /// Le projet est porté par l'URL, jamais par un paramètre : la passerelle réécrit
    /// `/v1/auth/oauth/{provider}/start` en `/v1/auth/{project_id}/oauth/{provider}/start`
    /// à partir de l'hôte (`project_subdomain.rs`), et `aura-auth` REFUSE en 400 un
    /// `project_id` encore envoyé en query — jamais ignoré en silence
    /// (`handlers/oauth.rs`, « Paramètre 'project_id' refusé »).
    ///
    /// # `query_params` — contrat aligné sur le SDK JavaScript (F3)
    ///
    /// Seules les clés d'[`OAUTH_FORWARDABLE_QUERY_PARAMS`] atteignent réellement le
    /// fournisseur. Toute autre est REFUSÉE — `AuraError` de code `invalid_oauth_query_param`,
    /// jamais recopiée dans l'URL. D'où le changement de signature : cette méthode rendait un
    /// `String`, elle rend désormais un `Result`, parce qu'elle peut légitimement refuser.
    ///
    /// Ce SDK recopiait auparavant `query_params` verbatim à la suite de `redirect_to` et
    /// `scopes`. Deux conséquences, toutes deux silencieuses :
    ///  - `redirect_to` fourni DEUX FOIS dans la query (la liste est un `Vec`, pas une map) —
    ///    or le backend refuse explicitement une clé répétée, donc 400 en pleine navigation ;
    ///  - `project_id`, `state`, `client_id` et consorts partaient au serveur, qui les refuse
    ///    de la même façon.
    ///
    /// L'autorité reste le backend (`OAUTH_FORWARDABLE_PARAMS`, `handlers/oauth.rs`) :
    /// l'endpoint est public et appelable sans SDK. Cette liste n'en est que le miroir, pour
    /// échouer AVANT la redirection pleine page.
    #[allow(clippy::result_large_err)]
    pub fn sign_in_with_oauth(
        &self,
        provider: &str,
        options: Option<OAuthSignInOptions>,
    ) -> Result<String, AuraError> {
        let opts = options.unwrap_or_default();
        let mut params: Vec<(String, String)> = Vec::new();
        if let Some(ref redirect_to) = opts.redirect_to {
            params.push(("redirect_to".to_string(), redirect_to.clone()));
        }
        if let Some(ref scopes) = opts.scopes {
            params.push(("scopes".to_string(), scopes.clone()));
        }
        if let Some(ref qp) = opts.query_params {
            // Ordre STABLE : une `HashMap` n'en a pas, et une URL qui change d'une exécution à
            // l'autre rend tout test et tout journal illisibles.
            let mut cles: Vec<&String> = qp.keys().collect();
            cles.sort();
            for k in cles {
                let v = &qp[k];
                if OAUTH_FORWARDABLE_QUERY_PARAMS.contains(&k.as_str()) {
                    params.push((k.clone(), v.clone()));
                    continue;
                }
                let raison = if OAUTH_SDK_OWNED_QUERY_PARAMS.contains(&k.as_str()) {
                    let dediee = match k.as_str() {
                        "redirect_uri" | "redirect_to" => "redirect_to",
                        "scopes" => "scopes",
                        "project_id" => "l'URL du projet passée à create_client()",
                        _ => "les options PKCE dédiées",
                    };
                    format!(
                        "il est construit par sign_in_with_oauth (utilisez l'option dédiée : \
                         {dediee})"
                    )
                } else {
                    format!(
                        "il n'est pas transmis au fournisseur. Seuls ces paramètres \
                         d'expérience de connexion le sont : {}",
                        OAUTH_FORWARDABLE_QUERY_PARAMS.join(", ")
                    )
                };
                return Err(AuraError::new(
                    400,
                    "invalid_oauth_query_param",
                    &format!("sign_in_with_oauth: query_params.{k} refusé — {raison}."),
                    None,
                ));
            }
        }
        let query = params
            .iter()
            .map(|(k, v)| format!("{}={}", urlencoding::encode(k), urlencoding::encode(v)))
            .collect::<Vec<_>>()
            .join("&");
        Ok(format!(
            "{}/v1/auth/oauth/{}/start?{}",
            self.client.base_url(),
            urlencoding::encode(provider),
            query
        ))
    }

    pub async fn sign_in_with_magic_link(
        &self,
        req: MagicLinkRequest,
    ) -> Result<AuraResponse<serde_json::Value>, AuraError> {
        self.client
            .request(
                reqwest::Method::POST,
                &format!("{}/magic-link", self.prefix()),
                RequestBody::Json(serde_json::to_value(&req).unwrap_or_default()),
            )
            .await
    }

    pub async fn sign_in_anonymously(&self) -> Result<AuraResponse<TokenPair>, AuraError> {
        let res = self
            .client
            .request::<TokenPair>(
                reqwest::Method::POST,
                &format!("{}/anonymous", self.prefix()),
                RequestBody::None,
            )
            .await?;

        if let Some(ref tp) = res.data {
            self.client.auth_store().save(
                tp.access_token.clone(),
                tp.refresh_token.clone(),
                tp.user.clone(),
            );
        }

        Ok(res)
    }

    pub async fn sign_out(&self) -> Result<AuraResponse<serde_json::Value>, AuraError> {
        let refresh_token = self.client.auth_store().refresh_token();
        let body = serde_json::json!({
            "refresh_token": refresh_token,
        });

        let res = self
            .client
            .request(
                reqwest::Method::POST,
                &format!("{}/logout", self.prefix()),
                RequestBody::Json(body),
            )
            .await;

        self.client.auth_store().clear();
        res
    }

    // -- Gestion de session --------------------------------------------------

    pub async fn refresh_session(&self) -> Result<AuraResponse<TokenPair>, AuraError> {
        let refresh_token = self.client.auth_store().refresh_token();
        let body = serde_json::json!({
            "refresh_token": refresh_token,
        });

        let res = self
            .client
            .request::<TokenPair>(
                reqwest::Method::POST,
                &format!("{}/refresh", self.prefix()),
                RequestBody::Json(body),
            )
            .await?;

        if let Some(ref tp) = res.data {
            self.client.auth_store().save(
                tp.access_token.clone(),
                tp.refresh_token.clone(),
                tp.user.clone(),
            );
        }

        Ok(res)
    }

    pub fn get_session(&self) -> (Option<String>, Option<User>) {
        (
            self.client.auth_store().token(),
            self.client.auth_store().user(),
        )
    }

    pub async fn list_sessions(&self) -> Result<AuraResponse<Vec<SessionInfo>>, AuraError> {
        self.client
            .request(
                reqwest::Method::GET,
                &format!("{}/sessions", self.prefix()),
                RequestBody::None,
            )
            .await
    }

    pub async fn revoke_session(
        &self,
        session_id: &str,
    ) -> Result<AuraResponse<serde_json::Value>, AuraError> {
        self.client
            .request(
                reqwest::Method::DELETE,
                &format!("{}/sessions/{}", self.prefix(), session_id),
                RequestBody::None,
            )
            .await
    }

    pub async fn revoke_all_sessions(&self) -> Result<AuraResponse<serde_json::Value>, AuraError> {
        let rt = self.client.auth_store().refresh_token();
        let body = serde_json::json!({
            "refresh_token": rt,
            "scope": "global",
        });

        self.client
            .request(
                reqwest::Method::POST,
                &format!("{}/logout", self.prefix()),
                RequestBody::Json(body),
            )
            .await
    }

    // -- Gestion de l'utilisateur --------------------------------------------

    pub async fn get_user(&self) -> Result<AuraResponse<User>, AuraError> {
        self.client
            .request(
                reqwest::Method::GET,
                &format!("{}/user", self.prefix()),
                RequestBody::None,
            )
            .await
    }

    pub async fn update_user(
        &self,
        req: UpdateUserRequest,
    ) -> Result<AuraResponse<User>, AuraError> {
        let res = self
            .client
            .request::<User>(
                reqwest::Method::PUT,
                &format!("{}/user", self.prefix()),
                RequestBody::Json(serde_json::to_value(&req).unwrap_or_default()),
            )
            .await?;

        if let Some(ref user) = res.data {
            let store = self.client.auth_store();
            if let (Some(token), Some(rt)) = (store.token(), store.refresh_token()) {
                store.save(token, rt, user.clone());
            }
        }

        Ok(res)
    }

    // -- Mot de passe / Récupération -----------------------------------------

    pub async fn reset_password_for_email(
        &self,
        req: PasswordResetRequest,
    ) -> Result<AuraResponse<serde_json::Value>, AuraError> {
        self.client
            .request(
                reqwest::Method::POST,
                &format!("{}/forgot-password", self.prefix()),
                RequestBody::Json(serde_json::to_value(&req).unwrap_or_default()),
            )
            .await
    }

    pub async fn update_password(
        &self,
        new_password: &str,
        current_password: Option<&str>,
    ) -> Result<AuraResponse<User>, AuraError> {
        let body = serde_json::json!({
            "password": new_password,
            "current_password": current_password,
        });

        self.client
            .request(
                reqwest::Method::PUT,
                &format!("{}/user", self.prefix()),
                RequestBody::Json(body),
            )
            .await
    }

    // -- MFA -----------------------------------------------------------------

    pub async fn mfa_enroll(&self) -> Result<AuraResponse<MfaEnrollResponse>, AuraError> {
        self.client
            .request(
                reqwest::Method::POST,
                &format!("{}/mfa/setup", self.prefix()),
                RequestBody::None,
            )
            .await
    }

    pub async fn mfa_verify_setup(
        &self,
        code: &str,
    ) -> Result<AuraResponse<serde_json::Value>, AuraError> {
        let body = serde_json::json!({ "code": code });
        self.client
            .request(
                reqwest::Method::POST,
                &format!("{}/mfa/setup/verify", self.prefix()),
                RequestBody::Json(body),
            )
            .await
    }

    pub async fn mfa_verify(
        &self,
        req: MfaVerifyRequest,
    ) -> Result<AuraResponse<TokenPair>, AuraError> {
        let res = self
            .client
            .request::<TokenPair>(
                reqwest::Method::POST,
                &format!("{}/mfa/verify-login", self.prefix()),
                RequestBody::Json(serde_json::to_value(&req).unwrap_or_default()),
            )
            .await?;

        if let Some(ref tp) = res.data {
            self.client.auth_store().save(
                tp.access_token.clone(),
                tp.refresh_token.clone(),
                tp.user.clone(),
            );
        }

        Ok(res)
    }

    pub async fn mfa_unenroll(
        &self,
        password: &str,
    ) -> Result<AuraResponse<serde_json::Value>, AuraError> {
        let body = serde_json::json!({ "password": password });
        self.client
            .request(
                reqwest::Method::POST,
                &format!("{}/mfa/disable", self.prefix()),
                RequestBody::Json(body),
            )
            .await
    }

    // -- OTP Email / SMS -----------------------------------------------------

    pub async fn sign_in_with_email_otp(
        &self,
        email: &str,
    ) -> Result<AuraResponse<serde_json::Value>, AuraError> {
        let body = serde_json::json!({ "email": email });
        self.client
            .request(
                reqwest::Method::POST,
                &format!("{}/email-otp/send", self.prefix()),
                RequestBody::Json(body),
            )
            .await
    }

    /// Point d'entrée UNIQUE de la vérification OTP — parité de surface avec `verifyOtp`
    /// (`aurabase-js`), `verifyOtp` (`aurabase-dart`) et `verify_otp` (`aurabase-py`).
    ///
    /// Il remplace les quatre méthodes `verify_email` / `verify_email_otp` / `verify_sms_otp` /
    /// `confirm_email_change`, retirées ici comme elles l'ont été de Dart et de Python. Le
    /// correctif qui les y avait supprimées ne nommait que ces deux SDK ; le SDK Rust les avait
    /// donc conservées, laissant quatre entrées de vérification là où les trois autres n'en
    /// exposaient qu'une (défaut K4).
    ///
    /// Le type est un ENUM et non une chaîne : les trois autres SDK doivent rendre une erreur
    /// `otp_type_unsupported` à l'exécution pour un type inconnu, le typage Rust rend ce cas
    /// inatteignable. Le PÉRIMÈTRE est exactement le leur — SIX flux, un par endpoint réellement
    /// servi par `aura-auth` (voir [`VerifyOtpParams`]).
    ///
    /// **F4 — `MagicLink` et `Recovery` ont été ajoutés** : ce SDK savait ENVOYER les deux liens
    /// sans pouvoir CONSOMMER le jeton qui revient. `invite` et `phone_change` restent absents
    /// de tous les SDK, faute d'endpoint de vérification côté backend.
    ///
    /// La réponse est rendue TELLE QUELLE (`serde_json::Value`) parce que sa forme dépend du
    /// flux : `signup`/`magiclink`/`email`/`sms`/`recovery` renvoient une paire de jetons (et
    /// posent la session), `email_change` renvoie l'utilisateur mis à jour (et ne fait que
    /// rafraîchir l'utilisateur stocké, la session restant la même) — même distinction qu'en
    /// Dart.
    pub async fn verify_otp(
        &self,
        params: VerifyOtpParams<'_>,
    ) -> Result<AuraResponse<serde_json::Value>, AuraError> {
        let (chemin, corps) = match params {
            VerifyOtpParams::Signup { token } => (
                format!("{}/verify-email", self.prefix()),
                serde_json::json!({ "token": token }),
            ),
            VerifyOtpParams::MagicLink { token } => (
                format!("{}/magic-link/verify", self.prefix()),
                serde_json::json!({ "token": token }),
            ),
            VerifyOtpParams::Recovery { token, password } => (
                format!("{}/reset-password", self.prefix()),
                serde_json::json!({ "token": token, "password": password }),
            ),
            VerifyOtpParams::Email { email, token } => (
                format!("{}/email-otp/verify", self.prefix()),
                serde_json::json!({ "email": email, "code": token }),
            ),
            VerifyOtpParams::Sms { phone, token } => (
                format!("{}/sms/verify", self.prefix()),
                serde_json::json!({ "phone": phone, "code": token }),
            ),
            VerifyOtpParams::EmailChange { token } => (
                format!("{}/user/confirm-email-change", self.prefix()),
                serde_json::json!({ "token": token }),
            ),
        };

        let res = self
            .client
            .request::<serde_json::Value>(reqwest::Method::POST, &chemin, RequestBody::Json(corps))
            .await?;

        let Some(ref valeur) = res.data else {
            return Ok(res);
        };

        if matches!(params, VerifyOtpParams::EmailChange { .. }) {
            // `email_change` ne délivre PAS de nouveaux jetons : il renvoie l'utilisateur mis à
            // jour. On ne remplace donc que l'utilisateur stocké, en réutilisant la session en
            // cours — et seulement s'il y en a une. Même comportement qu'en Dart.
            if let (Some(acces), Some(rafraichissement), Ok(utilisateur)) = (
                self.client.auth_store().token(),
                self.client.auth_store().refresh_token(),
                serde_json::from_value::<User>(valeur.clone()),
            ) {
                self.client
                    .auth_store()
                    .save(acces, rafraichissement, utilisateur);
            }
        } else if let Ok(paire) = serde_json::from_value::<TokenPair>(valeur.clone()) {
            self.client
                .auth_store()
                .save(paire.access_token, paire.refresh_token, paire.user);
        }

        Ok(res)
    }

    pub async fn sign_in_with_sms_otp(
        &self,
        phone: &str,
    ) -> Result<AuraResponse<serde_json::Value>, AuraError> {
        let body = serde_json::json!({ "phone": phone });
        self.client
            .request(
                reqwest::Method::POST,
                &format!("{}/sms/send", self.prefix()),
                RequestBody::Json(body),
            )
            .await
    }

    // -- Lien d'identités ----------------------------------------------------

    pub async fn list_identities(&self) -> Result<AuraResponse<Vec<IdentityInfo>>, AuraError> {
        self.client
            .request(
                reqwest::Method::GET,
                &format!("{}/user/identities", self.prefix()),
                RequestBody::None,
            )
            .await
    }

    pub async fn link_identity(
        &self,
        provider: &str,
    ) -> Result<AuraResponse<serde_json::Value>, AuraError> {
        self.client
            .request(
                reqwest::Method::POST,
                &format!("{}/user/identities/link/{}", self.prefix(), provider),
                RequestBody::None,
            )
            .await
    }

    pub async fn unlink_identity(
        &self,
        identity_id: &str,
    ) -> Result<AuraResponse<serde_json::Value>, AuraError> {
        self.client
            .request(
                reqwest::Method::DELETE,
                &format!("{}/user/identities/{}", self.prefix(), identity_id),
                RequestBody::None,
            )
            .await
    }

    // -- Autres (Mobile ID Token Exchange, Vérification email, etc.) ----------

    pub async fn sign_in_with_id_token(
        &self,
        provider: &str,
        id_token: &str,
        access_token: Option<&str>,
    ) -> Result<AuraResponse<TokenPair>, AuraError> {
        let body = serde_json::json!({
            "provider": provider,
            "id_token": id_token,
            "access_token": access_token,
        });

        let res = self
            .client
            .request::<TokenPair>(
                reqwest::Method::POST,
                &format!("{}/token", self.prefix()),
                RequestBody::Json(body),
            )
            .await?;

        if let Some(ref tp) = res.data {
            self.client.auth_store().save(
                tp.access_token.clone(),
                tp.refresh_token.clone(),
                tp.user.clone(),
            );
        }

        Ok(res)
    }

    pub async fn resend_verification_email(
        &self,
        email: Option<&str>,
    ) -> Result<AuraResponse<serde_json::Value>, AuraError> {
        let email_to_send = match email {
            Some(e) => Some(e.to_string()),
            None => self.client.auth_store().user().and_then(|u| u.email),
        };
        let body = serde_json::json!({ "email": email_to_send });

        self.client
            .request(
                reqwest::Method::POST,
                &format!("{}/resend-verification", self.prefix()),
                RequestBody::Json(body),
            )
            .await
    }

    pub async fn regenerate_recovery_codes(
        &self,
        code: &str,
    ) -> Result<AuraResponse<serde_json::Value>, AuraError> {
        let body = serde_json::json!({ "code": code });
        self.client
            .request(
                reqwest::Method::POST,
                &format!("{}/mfa/recovery-codes/regenerate", self.prefix()),
                RequestBody::Json(body),
            )
            .await
    }
}

// ----------------------------------------------------------------------------
// AuthAdminService
// ----------------------------------------------------------------------------

pub struct AuthAdminService {
    client: AuraClient,
}

impl AuthAdminService {
    pub fn new(client: AuraClient) -> Self {
        Self { client }
    }

    fn prefix(&self) -> String {
        "/v1/auth/admin".to_string()
    }

    // -- Users ---------------------------------------------------------------

    pub async fn list_users(
        &self,
        limit: Option<u32>,
        offset: Option<u32>,
        search: Option<&str>,
    ) -> Result<AuraResponse<Vec<AdminUser>>, AuraError> {
        let mut query = Vec::new();
        if let Some(l) = limit {
            query.push(format!("limit={}", l));
        }
        if let Some(o) = offset {
            query.push(format!("offset={}", o));
        }
        if let Some(s) = search {
            query.push(format!("search={}", urlencoding::encode(s)));
        }

        let qs = if query.is_empty() {
            "".to_string()
        } else {
            format!("?{}", query.join("&"))
        };

        self.client
            .request(
                reqwest::Method::GET,
                &format!("{}/users{}", self.prefix(), qs),
                RequestBody::None,
            )
            .await
    }

    pub async fn get_user(&self, user_id: &str) -> Result<AuraResponse<AdminUser>, AuraError> {
        self.client
            .request(
                reqwest::Method::GET,
                &format!("{}/users/{}", self.prefix(), user_id),
                RequestBody::None,
            )
            .await
    }

    pub async fn create_user(
        &self,
        req: AdminCreateUserRequest,
    ) -> Result<AuraResponse<AdminUser>, AuraError> {
        self.client
            .request(
                reqwest::Method::POST,
                &format!("{}/users", self.prefix()),
                RequestBody::Json(serde_json::to_value(&req).unwrap_or_default()),
            )
            .await
    }

    pub async fn update_user(
        &self,
        user_id: &str,
        req: AdminUpdateUserRequest,
    ) -> Result<AuraResponse<AdminUser>, AuraError> {
        self.client
            .request(
                reqwest::Method::PUT,
                &format!("{}/users/{}", self.prefix(), user_id),
                RequestBody::Json(serde_json::to_value(&req).unwrap_or_default()),
            )
            .await
    }

    pub async fn delete_user(
        &self,
        user_id: &str,
    ) -> Result<AuraResponse<serde_json::Value>, AuraError> {
        self.client
            .request(
                reqwest::Method::DELETE,
                &format!("{}/users/{}", self.prefix(), user_id),
                RequestBody::None,
            )
            .await
    }

    pub async fn ban_user(
        &self,
        user_id: &str,
    ) -> Result<AuraResponse<serde_json::Value>, AuraError> {
        self.client
            .request(
                reqwest::Method::POST,
                &format!("{}/users/{}/ban", self.prefix(), user_id),
                RequestBody::None,
            )
            .await
    }

    pub async fn unban_user(
        &self,
        user_id: &str,
    ) -> Result<AuraResponse<serde_json::Value>, AuraError> {
        self.client
            .request(
                reqwest::Method::POST,
                &format!("{}/users/{}/unban", self.prefix(), user_id),
                RequestBody::None,
            )
            .await
    }

    pub async fn generate_link(
        &self,
        user_id: &str,
        link_type: &str,
        redirect_to: Option<&str>,
    ) -> Result<AuraResponse<serde_json::Value>, AuraError> {
        let body = serde_json::json!({
            "type": link_type,
            "redirect_to": redirect_to,
        });

        self.client
            .request(
                reqwest::Method::POST,
                &format!("{}/users/{}/generate-link", self.prefix(), user_id),
                RequestBody::Json(body),
            )
            .await
    }

    // -- Audit log -----------------------------------------------------------

    pub async fn get_audit_log(
        &self,
        limit: Option<u32>,
        offset: Option<u32>,
    ) -> Result<AuraResponse<Vec<AuditLogEntry>>, AuraError> {
        let mut query = Vec::new();
        if let Some(l) = limit {
            query.push(format!("limit={}", l));
        }
        if let Some(o) = offset {
            query.push(format!("offset={}", o));
        }

        let qs = if query.is_empty() {
            "".to_string()
        } else {
            format!("?{}", query.join("&"))
        };

        self.client
            .request(
                reqwest::Method::GET,
                &format!("{}/audit-log{}", self.prefix(), qs),
                RequestBody::None,
            )
            .await
    }

    // -- Settings ------------------------------------------------------------

    pub async fn get_settings(&self) -> Result<AuraResponse<AuthSettings>, AuraError> {
        self.client
            .request(
                reqwest::Method::GET,
                &format!("{}/settings", self.prefix()),
                RequestBody::None,
            )
            .await
    }

    pub async fn update_settings(
        &self,
        req: serde_json::Value,
    ) -> Result<AuraResponse<AuthSettings>, AuraError> {
        self.client
            .request(
                reqwest::Method::PUT,
                &format!("{}/settings", self.prefix()),
                RequestBody::Json(req),
            )
            .await
    }

    // -- Email templates -----------------------------------------------------

    pub async fn list_email_templates(
        &self,
    ) -> Result<AuraResponse<Vec<serde_json::Value>>, AuraError> {
        self.client
            .request(
                reqwest::Method::GET,
                &format!("{}/email-templates", self.prefix()),
                RequestBody::None,
            )
            .await
    }

    pub async fn get_email_template(
        &self,
        template_type: &str,
    ) -> Result<AuraResponse<serde_json::Value>, AuraError> {
        self.client
            .request(
                reqwest::Method::GET,
                &format!("{}/email-templates/{}", self.prefix(), template_type),
                RequestBody::None,
            )
            .await
    }

    pub async fn update_email_template(
        &self,
        template_type: &str,
        req: EmailTemplateUpdate,
    ) -> Result<AuraResponse<serde_json::Value>, AuraError> {
        self.client
            .request(
                reqwest::Method::PUT,
                &format!("{}/email-templates/{}", self.prefix(), template_type),
                RequestBody::Json(serde_json::to_value(&req).unwrap_or_default()),
            )
            .await
    }

    pub async fn delete_email_template(
        &self,
        template_type: &str,
    ) -> Result<AuraResponse<serde_json::Value>, AuraError> {
        self.client
            .request(
                reqwest::Method::DELETE,
                &format!("{}/email-templates/{}", self.prefix(), template_type),
                RequestBody::None,
            )
            .await
    }
}