use crate::extractors::client_auth::APIClientAuth;
use crate::server::{HttpFailure, HttpResult};
use crate::utils::matrix_utils::ApiMxcURI;
use actix_web::{web, HttpResponse};
use ruma::api::client::{membership, state};
use ruma::events::StateEventType;
use ruma::{OwnedMxcUri, OwnedRoomId};
use serde::de::DeserializeOwned;

#[derive(serde::Serialize)]
struct GetRoomsMembershipsResponse {
    rooms: Vec<OwnedRoomId>,
}

/// Get the list of rooms the user has joined
pub async fn joined_rooms(auth: APIClientAuth) -> HttpResult {
    let res = auth
        .send_request(membership::joined_rooms::v3::Request::default())
        .await?;

    Ok(HttpResponse::Ok().json(GetRoomsMembershipsResponse {
        rooms: res.joined_rooms,
    }))
}

#[derive(serde::Deserialize)]
pub struct RoomIDInPath {
    room_id: OwnedRoomId,
}

#[derive(serde::Serialize)]
struct GetRoomInfoResponse {
    name: Option<String>,
    avatar: Option<ApiMxcURI>,
}

/// Get a room information
async fn get_room_info<E: DeserializeOwned>(
    auth: &APIClientAuth,
    room_id: OwnedRoomId,
    event_type: StateEventType,
    field: &str,
) -> anyhow::Result<Option<E>, HttpFailure> {
    let res = auth
        .send_request(state::get_state_events_for_key::v3::Request::new(
            room_id,
            event_type,
            String::default(),
        ))
        .await?;

    Ok(res.content.get_field(field)?)
}

/// Get room information
pub async fn info(auth: APIClientAuth, path: web::Path<RoomIDInPath>) -> HttpResult {
    let room_name: Option<String> = get_room_info(
        &auth,
        path.room_id.clone(),
        StateEventType::RoomName,
        "name",
    )
    .await
    .ok()
    .flatten();

    let room_avatar: Option<OwnedMxcUri> = get_room_info(
        &auth,
        path.room_id.clone(),
        StateEventType::RoomAvatar,
        "url",
    )
    .await
    .ok()
    .flatten();

    Ok(HttpResponse::Ok().json(GetRoomInfoResponse {
        name: room_name,
        avatar: room_avatar.map(ApiMxcURI),
    }))
}