use crate::protos::auth as proto;
use crate::{Accounts, KenAuthError};
impl Accounts {
    pub async fn check_health(&self) -> Result<(), KenAuthError> {
        self.cache()
            .ping()
            .await
            .map_err(|error| KenAuthError::Unavailable(error.to_string()))
    }
    #[allow(clippy::too_many_arguments)]

    pub async fn list_user_sessions(
        &self,
        user_id: i64,
        include_revoked: bool,
        include_expired: bool,
        page: proto::common::v1::PageRequest,
    ) -> Result<proto::v1::ListUserSessionsResponse, KenAuthError> {
        let request_id = crate::share::audit::current_request_id();
        self.list_user_sessions_inner(
            Some(request_id.as_str()),
            proto::v1::ListUserSessionsRequest {
                user_id,
                include_revoked,
                include_expired,
                page: Some(page),
            },
        )
        .await
    }
    pub async fn revoke_user_sessions(
        &self,
        user_id: i64,
        except_session_id: &str,
        reason: &str,
        bump_security_version: bool,
    ) -> Result<proto::v1::RevokeUserSessionsResponse, KenAuthError> {
        let request_id = crate::share::audit::current_request_id();
        self.revoke_user_sessions_inner(
            Some(request_id.as_str()),
            proto::v1::RevokeUserSessionsRequest {
                user_id,
                except_session_id: except_session_id.to_string(),
                reason: reason.to_string(),
                bump_security_version,
            },
        )
        .await
    }
    pub async fn get_session(
        &self,
        user_id: i64,
        version: i32,
        session_id: &str,
    ) -> Result<proto::internal::v1::AuthorityAccess, KenAuthError> {
        let request_id = crate::share::audit::current_request_id();
        self.get_session_inner(
            Some(request_id.as_str()),
            proto::internal::v1::GetSessionRequest {
                user_id,
                version,
                session_id: session_id.to_string(),
            },
        )
        .await
        .map(|response| response.access.unwrap_or_default())
    }
    pub async fn delete_account(&self, user_id: i64, reason: &str) -> Result<(), KenAuthError> {
        let request_id = crate::share::audit::current_request_id();
        self.delete_account_inner(
            Some(request_id.as_str()),
            proto::internal::v1::DeleteAccountRequest {
                user_id,
                reason: reason.to_string(),
            },
        )
        .await?;
        Ok(())
    }
    pub async fn cancel_account_deletion(&self, user_id: i64) -> Result<(), KenAuthError> {
        let request_id = crate::share::audit::current_request_id();
        self.cancel_account_deletion_inner(
            Some(request_id.as_str()),
            proto::internal::v1::CancelAccountDeletionRequest { user_id },
        )
        .await?;
        Ok(())
    }
    pub async fn purge_account(&self, user_id: i64) -> Result<(), KenAuthError> {
        let request_id = crate::share::audit::current_request_id();
        self.purge_account_inner(
            Some(request_id.as_str()),
            proto::internal::v1::PurgeAccountRequest { user_id },
        )
        .await?;
        Ok(())
    }
    pub async fn batch_get_authority_users(
        &self,
        user_ids: Vec<i64>,
    ) -> Result<Vec<proto::internal::v1::AuthorityUser>, KenAuthError> {
        let request_id = crate::share::audit::current_request_id();
        self.batch_get_user_inner(
            Some(request_id.as_str()),
            proto::internal::v1::BatchGetUserRequest { user_ids },
        )
        .await
        .map(|response| response.users)
    }
    pub async fn get_user_status(
        &self,
        user_id: i64,
    ) -> Result<proto::common::v1::UserStatus, KenAuthError> {
        let request_id = crate::share::audit::current_request_id();
        let user = Some(proto::common::v1::UserRef {
            key: Some(proto::common::v1::user_ref::Key::UserId(user_id)),
        });
        self.get_user_status_inner(
            Some(request_id.as_str()),
            proto::v1::GetUserStatusRequest { user },
        )
        .await
        .map(|response| response.status.unwrap_or_default())
    }
    pub async fn get_user_public_by_ref(
        &self,
        key: proto::common::v1::user_ref::Key,
    ) -> Result<proto::common::v1::UserPublic, KenAuthError> {
        let request_id = crate::share::audit::current_request_id();
        let user = Some(proto::common::v1::UserRef { key: Some(key) });
        self.get_user_public_inner(
            Some(request_id.as_str()),
            proto::v1::GetUserPublicRequest { user },
        )
        .await?
        .user
        .ok_or(KenAuthError::NotFound)
    }
    pub async fn get_authority_user(
        &self,
        user_id: i64,
    ) -> Result<proto::internal::v1::AuthorityUser, KenAuthError> {
        let request_id = crate::share::audit::current_request_id();
        self.get_user_inner(
            Some(request_id.as_str()),
            proto::internal::v1::GetUserRequest { user_id },
        )
        .await?
        .user
        .ok_or(KenAuthError::NotFound)
    }
    #[allow(clippy::too_many_arguments)]
    pub async fn update_authority_user(
        &self,
        user_id: i64,
        username: Option<String>,
        displayname: Option<String>,
        clear_displayname: bool,
        public_show_email: Option<bool>,
        version: i32,
    ) -> Result<proto::internal::v1::AuthorityUser, KenAuthError> {
        let request_id = crate::share::audit::current_request_id();
        self.update_user_inner(
            Some(request_id.as_str()),
            proto::internal::v1::UpdateUserRequest {
                user_id,
                patch: Some(proto::internal::v1::AuthorityUserPatch {
                    version,
                    username,
                    displayname,
                    clear_displayname,
                    public_show_email,
                }),
            },
        )
        .await?
        .user
        .ok_or(KenAuthError::NotFound)
    }
    pub async fn batch_get_user_public(
        &self,
        user_ids: Vec<i64>,
    ) -> Result<Vec<proto::common::v1::UserPublic>, KenAuthError> {
        let request_id = crate::share::audit::current_request_id();
        self.batch_get_user_public_inner(
            Some(request_id.as_str()),
            proto::v1::BatchGetUserPublicRequest { user_ids },
        )
        .await
        .map(|response| response.users)
    }
    pub async fn get_user_public(
        &self,
        user_id: i64,
    ) -> Result<proto::common::v1::UserPublic, KenAuthError> {
        let request_id = crate::share::audit::current_request_id();
        let user = Some(proto::common::v1::UserRef {
            key: Some(proto::common::v1::user_ref::Key::UserId(user_id)),
        });
        self.get_user_public_inner(
            Some(request_id.as_str()),
            proto::v1::GetUserPublicRequest { user },
        )
        .await?
        .user
        .ok_or(KenAuthError::NotFound)
    }
    pub async fn revoke_session(
        &self,
        user_id: i64,
        session_id: &str,
        reason: &str,
    ) -> Result<(), KenAuthError> {
        let request_id = crate::share::audit::current_request_id();
        self.revoke_session_inner(
            Some(request_id.as_str()),
            proto::v1::RevokeSessionRequest {
                user_id,
                session_id: session_id.to_string(),
                reason: reason.to_string(),
            },
        )
        .await?;
        Ok(())
    }
    pub async fn ensure_bot_user(
        &self,
        username: &str,
        displayname: &str,
        system: bool,
    ) -> Result<proto::common::v1::UserPublic, KenAuthError> {
        let request_id = crate::share::audit::current_request_id();
        self.ensure_bot_user_inner(
            Some(request_id.as_str()),
            proto::v1::EnsureBotUserRequest {
                username: username.to_string(),
                displayname: displayname.to_string(),
                system,
            },
        )
        .await?
        .user
        .ok_or(KenAuthError::NotFound)
    }
}