macltok

use futures_util::{StreamExt, stream};

use matrix_sdk::{

    Client, Room, RoomState,

    deserialized_responses::SyncOrStrippedState,

    latest_events::LatestEventValue,

    ruma::events::{

        AnyMessageLikeEventContent, AnySyncMessageLikeEvent, AnySyncTimelineEvent, StateEventType,

        SyncStateEvent,

        room::message::{Relation, RoomMessageEventContent},

        space::child::SpaceChildEventContent,

    },

};

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

use ruma::{

    OwnedRoomId,

    serde::{JsonObject, Raw},

};

use super::message_kind;

use crate::{

    LatestEvent, MediaId, MessageKind, RoomHero, RoomMembership, RoomNotificationMode, RoomSummary,

    SendState, SpaceChild, space_order,

};

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

        unread_notifications: room.num_unread_notifications(),

        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().as_deref().map(MediaId::plain),

        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.as_deref().map(MediaId::plain),

            })

            .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,

        space_order: if room.is_space() {

            stored_space_order(room).await

        } else {

            None

        },

        can_edit_packs: super::can_edit_packs(room).await,

        pinned_events: room.pinned_event_ids().unwrap_or_default(),

        can_pin: room.state() == RoomState::Joined

            && room.power_levels().await.is_ok_and(|levels| {

                levels.user_can_send_state(room.own_user_id(), StateEventType::RoomPinnedEvents)

            }),

    }

}

/// None when unset or when another client wrote something msc3230 doesn't allow

pub(crate) async fn stored_space_order(room: &Room) -> Option<String> {

    room.account_data(space_order::EVENT_TYPE.into())

        .await

        .ok()??

        .get_field::<Raw<JsonObject>>("content")

        .ok()??

        .get_field::<String>("order")

        .ok()?

        .filter(|order| space_order::valid(order))

}

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 own = || Some(room.own_user_id().to_owned());

    let local = |local: &matrix_sdk::latest_events::LocalLatestEventValue| {

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

            Ok(AnyMessageLikeEventContent::RoomMessage(content)) => preview(&content),

            _ => (None, None),

        };

        (preview, Some(local.timestamp))

    };

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

        LatestEventValue::None => return None,

        LatestEventValue::Remote(event) => {

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

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

                    message,

                ))) => message

                    .as_original()

                    .map_or((None, None), |message| preview(&message.content)),

                _ => (None, None),

            };

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

        }

        LatestEventValue::RemoteInvite {

            timestamp, inviter, ..

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

        LatestEventValue::LocalIsSending(value) => {

            let (preview, timestamp) = local(&value);

            (own(), preview, timestamp, SendState::Sending)

        }

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

            let (preview, timestamp) = local(&value);

            (own(), preview, timestamp, SendState::Sent)

        }

        // the sdk won't say whether it'll retry, so assume the user has to

        LatestEventValue::LocalCannotBeSent(value) => {

            let (preview, timestamp) = local(&value);

            (

                own(),

                preview,

                timestamp,

                SendState::Failed { will_retry: false },

            )

        }

    };

    Some(LatestEvent {

        sender,

        kind,

        body,

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

        send_state,

    })

}

/// the latest event of an edited message is the edit, whose own body is the `* fallback`

fn preview(content: &RoomMessageEventContent) -> (Option<MessageKind>, Option<String>) {

    let msgtype = match &content.relates_to {

        Some(Relation::Replacement(replacement)) => &replacement.new_content.msgtype,

        _ => &content.msgtype,

    };

    (Some(message_kind(msgtype)), Some(msgtype.body().to_owned()))

}

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.as_deref().map(MediaId::plain),

        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,

    }

}