use crate::controllers::HttpResult;
use crate::extractors::matrix_client_extractor::MatrixClientExtractor;
use actix_web::{HttpResponse, web};
use futures_util::{StreamExt, stream};
use matrix_sdk::ruma::api::client::profile::{AvatarUrl, DisplayName, get_profile};
use matrix_sdk::ruma::{OwnedMxcUri, OwnedUserId};

#[derive(serde::Deserialize)]
pub struct UserIDInPath {
    user_id: OwnedUserId,
}

#[derive(serde::Serialize)]
struct ProfileResponse {
    user_id: OwnedUserId,
    display_name: Option<String>,
    avatar: Option<OwnedMxcUri>,
}

impl ProfileResponse {
    pub fn from(user_id: OwnedUserId, r: get_profile::v3::Response) -> anyhow::Result<Self> {
        Ok(Self {
            user_id,
            display_name: r.get_static::<DisplayName>()?,
            avatar: r.get_static::<AvatarUrl>()?,
        })
    }
}

/// Get user profile
pub async fn get_profile(
    client: MatrixClientExtractor,
    path: web::Path<UserIDInPath>,
) -> HttpResult {
    let profile = client
        .client
        .client
        .account()
        .fetch_user_profile_of(&path.user_id)
        .await?;

    Ok(HttpResponse::Ok().json(ProfileResponse::from(path.user_id.clone(), profile)?))
}

/// Get multiple users profiles
pub async fn get_multiple(client: MatrixClientExtractor) -> HttpResult {
    let users = client.auth.decode_json_body::<Vec<OwnedUserId>>()?;

    let list = stream::iter(users)
        .then(async |user_id| {
            client
                .client
                .client
                .account()
                .fetch_user_profile_of(&user_id)
                .await
                .map(|r| ProfileResponse::from(user_id, r))
        })
        .collect::<Vec<_>>()
        .await
        .into_iter()
        .collect::<Result<Vec<_>, _>>()?
        .into_iter()
        .collect::<Result<Vec<_>, _>>()?;

    Ok(HttpResponse::Ok().json(list))
}