macltok

use futures_util::{StreamExt, stream};

use matrix_sdk::{Client, Room, RoomState};

use crate::{RoomMembership, RoomNotificationMode, RoomSummary};

pub(crate) async fn room_summaries(client: &Client) -> Vec<RoomSummary> {

    let mut summaries = stream::iter(client.rooms())

        .map(|room| async move { room_summary(&room).await })

        .buffer_unordered(16)

        .collect::<Vec<_>>()

        .await;

    summaries.sort_by(|left, right| {

        right

            .latest_event_timestamp_ms

            .cmp(&left.latest_event_timestamp_ms)

            .then_with(|| left.name.to_lowercase().cmp(&right.name.to_lowercase()))

            .then_with(|| left.room_id.cmp(&right.room_id))

    });

    summaries

}

async fn room_summary(room: &Room) -> RoomSummary {

    let name = room

        .display_name()

        .await

        .map(|name| name.to_string())

        .unwrap_or_else(|_| room.room_id().to_string());

    let custom_notification_mode = room.user_defined_notification_mode().await;

    let effective_notification_mode = match custom_notification_mode {

        Some(mode) => Some(mode),

        None => room.notification_mode().await,

    };

    RoomSummary {

        room_id: room.room_id().to_owned(),

        name,

        membership: match room.state() {

            RoomState::Joined => RoomMembership::Joined,

            RoomState::Invited => RoomMembership::Invited,

            RoomState::Left => RoomMembership::Left,

            RoomState::Knocked => RoomMembership::Knocked,

            RoomState::Banned => RoomMembership::Banned,

        },

        unread_messages: room.num_unread_messages(),

        unread_mentions: room.num_unread_mentions(),

        encrypted: room.encryption_state().is_encrypted(),

        space: room.is_space(),

        direct: room.is_direct().await.unwrap_or(false),

        favourite: room.is_favourite(),

        low_priority: room.is_low_priority(),

        avatar: room.avatar_url(),

        latest_event_timestamp_ms: room

            .latest_event_timestamp()

            .map(|value| value.get().into()),

        notification_mode: effective_notification_mode.map(notification_mode),

        notification_mode_custom: custom_notification_mode.is_some(),

    }

}

pub(crate) const fn notification_mode(

    mode: matrix_sdk::notification_settings::RoomNotificationMode,

) -> RoomNotificationMode {

    match mode {

        matrix_sdk::notification_settings::RoomNotificationMode::AllMessages => {

            RoomNotificationMode::AllMessages

        }

        matrix_sdk::notification_settings::RoomNotificationMode::MentionsAndKeywordsOnly => {

            RoomNotificationMode::MentionsAndKeywordsOnly

        }

        matrix_sdk::notification_settings::RoomNotificationMode::Mute => RoomNotificationMode::Mute,

    }

}