macltok

use futures_util::{StreamExt, stream};

use matrix_sdk::{

    Client, Room, RoomState,

    deserialized_responses::SyncOrStrippedState,

    latest_events::LatestEventValue,

    ruma::events::{

        AnyMessageLikeEventContent, AnySyncMessageLikeEvent, AnySyncTimelineEvent, SyncStateEvent,

        space::child::SpaceChildEventContent,

    },

};

use matrix_sdk_ui::spaces::{SpaceRoom, SpaceService};

use ruma::OwnedRoomId;

use crate::{

    LatestEvent, RoomHero, RoomMembership, RoomNotificationMode, RoomSummary, SendState, SpaceChild,

};

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

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

        .map(|room| async move { room_summary(&room, spaces).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, spaces: &SpaceService) -> 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,

    };

    let inviter = match room.state() {

        RoomState::Invited => room

            .invite_details()

            .await

            .ok()

            .map(|invite| invite.inviter_id),

        _ => None,

    };

    let children = if room.is_space() {

        space_children(room).await

    } else {

        Vec::new()

    };

    RoomSummary {

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

        name,

        membership: membership(room.state()),

        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()),

        latest_event: latest_event(room),

        notification_mode: effective_notification_mode.map(notification_mode),

        notification_mode_custom: custom_notification_mode.is_some(),

        topic: room.topic(),

        canonical_alias: room.canonical_alias(),

        joined_members: room.joined_members_count(),

        invited_members: room.invited_members_count(),

        heroes: room

            .heroes()

            .into_iter()

            .map(|hero| RoomHero {

                user_id: hero.user_id,

                display_name: hero.display_name,

                avatar: hero.avatar_url,

            })

            .collect(),

        successor: room.successor_room().map(|successor| successor.room_id),

        inviter,

        parent_spaces: spaces

            .joined_parents_of_child(room.room_id())

            .await

            .into_iter()

            .map(|parent| parent.room_id)

            .collect(),

        children,

    }

}

const fn membership(state: RoomState) -> RoomMembership {

    match state {

        RoomState::Joined => RoomMembership::Joined,

        RoomState::Invited => RoomMembership::Invited,

        RoomState::Left => RoomMembership::Left,

        RoomState::Knocked => RoomMembership::Knocked,

        RoomState::Banned => RoomMembership::Banned,

    }

}

/// what the space itself lists, straight from local state. redacted children don't count

async fn space_children(room: &Room) -> Vec<OwnedRoomId> {

    let Ok(events) = room

        .get_state_events_static::<SpaceChildEventContent>()

        .await

    else {

        return Vec::new();

    };

    events

        .into_iter()

        .filter_map(|event| match event.deserialize().ok()? {

            SyncOrStrippedState::Sync(SyncStateEvent::Original(event)) => Some(event.state_key),

            SyncOrStrippedState::Stripped(event) => Some(event.state_key),

            SyncOrStrippedState::Sync(SyncStateEvent::Redacted(_)) => None,

        })

        .collect()

}

fn latest_event(room: &Room) -> Option<LatestEvent> {

    let (sender, body, timestamp, send_state) = match room.latest_event() {

        LatestEventValue::None => return None,

        LatestEventValue::Remote(event) => {

            let body = match event.raw().deserialize() {

                Ok(AnySyncTimelineEvent::MessageLike(AnySyncMessageLikeEvent::RoomMessage(

                    message,

                ))) => message

                    .as_original()

                    .map(|message| message.content.body().to_owned()),

                _ => None,

            };

            (event.sender(), body, event.timestamp(), SendState::Sent)

        }

        LatestEventValue::RemoteInvite {

            timestamp, inviter, ..

        } => (inviter, None, Some(timestamp), SendState::Sent),

        LatestEventValue::LocalIsSending(local) => local_event(room, &local, SendState::Sending),

        LatestEventValue::LocalHasBeenSent { value, .. } => {

            local_event(room, &value, SendState::Sent)

        }

        LatestEventValue::LocalCannotBeSent(local) => {

            local_event(room, &local, SendState::Failed { retriable: true })

        }

    };

    Some(LatestEvent {

        sender,

        body,

        timestamp_ms: timestamp.map(|timestamp| timestamp.get().into()),

        send_state,

    })

}

type LatestParts = (

    Option<ruma::OwnedUserId>,

    Option<String>,

    Option<ruma::MilliSecondsSinceUnixEpoch>,

    SendState,

);

fn local_event(

    room: &Room,

    local: &matrix_sdk::latest_events::LocalLatestEventValue,

    send_state: SendState,

) -> LatestParts {

    let body = match local.content.deserialize() {

        Ok(AnyMessageLikeEventContent::RoomMessage(content)) => Some(content.body().to_owned()),

        _ => None,

    };

    (

        room.own_user_id().to_owned().into(),

        body,

        Some(local.timestamp),

        send_state,

    )

}

pub(crate) fn space_child(room: SpaceRoom) -> SpaceChild {

    SpaceChild {

        name: room.display_name,

        room_id: room.room_id,

        topic: room.topic,

        avatar: room.avatar_url,

        canonical_alias: room.canonical_alias,

        joined_members: room.num_joined_members,

        space: room.room_type == Some(ruma::room::RoomType::Space),

        children_count: room.children_count,

        membership: room.state.map(membership),

        via: room.via,

        suggested: room.suggested,

        world_readable: room.world_readable,

        guest_can_join: room.guest_can_join,

    }

}

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,

    }

}