use crate::Accounts;
use crate::errors::KenAuthError;
use crate::protos::auth::common::v1::UserPublic;
use api::users::UserDto;
use std::collections::HashMap;
pub async fn load_user_briefs(
    accounts: &Accounts,
    uids: &[i64],
) -> Result<HashMap<i64, UserDto>, KenAuthError> {
    let users = load_public_users(accounts, uids).await?;
    Ok(users
        .into_iter()
        .map(|(uid, public)| (uid, UserDto::from_public(&public)))
        .collect())
}

/// Bulk identity lookup. KenApi keeps no local copy of usernames, display
/// names or avatars: every caller goes through KenOAuth.
pub async fn load_public_users(
    accounts: &Accounts,
    uids: &[i64],
) -> Result<HashMap<i64, UserPublic>, KenAuthError> {
    if uids.is_empty() {
        return Ok(HashMap::new());
    }
    let mut ids: Vec<i64> = uids.to_vec();
    ids.sort_unstable();
    ids.dedup();
    let client = accounts;
    let users = client.batch_get_user_public(ids).await?;
    Ok(users.into_iter().map(|user| (user.user_id, user)).collect())
}

pub async fn get_public_user(
    accounts: &Accounts,
    uid: i64,
) -> Result<Option<UserPublic>, KenAuthError> {
    let client = accounts;
    match client.get_user_public(uid).await {
        Ok(user) => Ok(Some(user)),
        Err(crate::errors::KenAuthError::NotFound) => Ok(None),
        Err(error) => Err(error),
    }
}

pub async fn find_by_email(
    accounts: &Accounts,
    email: &str,
) -> Result<Option<UserPublic>, KenAuthError> {
    let client = accounts;
    match client
        .get_user_public_by_ref(proto::auth::common::v1::user_ref::Key::Email(
            email.to_string(),
        ))
        .await
    {
        Ok(user) => Ok(Some(user)),
        Err(crate::errors::KenAuthError::NotFound) => Ok(None),
        Err(error) => Err(error),
    }
}

pub async fn find_by_username(
    accounts: &Accounts,
    username: &str,
) -> Result<Option<UserPublic>, KenAuthError> {
    let client = accounts;
    match client
        .get_user_public_by_ref(proto::auth::common::v1::user_ref::Key::Username(
            username.to_string(),
        ))
        .await
    {
        Ok(user) => Ok(Some(user)),
        Err(crate::errors::KenAuthError::NotFound) => Ok(None),
        Err(error) => Err(error),
    }
}