macltok

use std::sync::Arc;

use matrix_sdk_crypto::types::events::UtdCause as SdkUtdCause;

use matrix_sdk_ui::{

    eyeball_im::VectorDiff,

    timeline::{

        AnyOtherStateEventContentChange, EncryptedMessage, EventSendState, EventTimelineItem,

        MembershipChange as SdkMembershipChange, MsgLikeContent, MsgLikeKind, Profile,

        TimelineDetails, TimelineEventItemId, TimelineItem as SdkTimelineItem, TimelineItemContent,

        TimelineItemKind, VirtualTimelineItem,

    },

};

use ruma::{

    MxcUri, OwnedEventId, UserId,

    events::{

        StateEventContentChange,

        room::message::{MessageFormat, MessageType},

    },

};

use crate::{

    Change, HistoryGap, HistoryGapLifecycle, MediaId, MembershipChange, Message, MessageKind,

    MessageMentions, Reaction, ReplyDetails, ReplyReference, SendState, Sender, ThreadSummary,

    TimelineContent, TimelineDiff, TimelineEvent, TimelineItem, TimelineItemId, UtdCause,

};

use super::link_preview::sender_previews;

use super::media::{

    MediaRegistration, MediaScope, media_descriptor_for_sticker, media_from_message,

    media_identity, media_registrations_for_item,

};

#[derive(Default)]

pub(crate) struct NormalisedTimeline {

    pub(crate) items: imbl::Vector<TimelineItem>,

    pub(crate) media: Vec<MediaRegistration>,

    /// replies whose target isn't loaded, so somebody should go and ask for it

    pub(crate) missing_replies: Vec<OwnedEventId>,

}

pub(crate) struct NormalisedTimelineDiffs {

    pub(crate) diffs: Vec<TimelineDiff>,

    pub(crate) media: Vec<MediaRegistration>,

    pub(crate) missing_replies: Vec<OwnedEventId>,

}

struct Normaliser<'a> {

    current_user_id: Option<&'a UserId>,

    scope: &'a MediaScope,

    media: Vec<MediaRegistration>,

    missing_replies: Vec<OwnedEventId>,

}

impl Normaliser<'_> {

    fn item(&mut self, item: &SdkTimelineItem) -> TimelineItem {

        self.media

            .extend(media_registrations_for_item(item, self.scope));

        match item.kind() {

            TimelineItemKind::Event(event) => {

                TimelineItem::Event(Box::new(self.event(item, event)))

            }

            TimelineItemKind::Virtual(VirtualTimelineItem::DateDivider(timestamp)) => {

                TimelineItem::DayDivider {

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

                }

            }

            TimelineItemKind::Virtual(VirtualTimelineItem::ReadMarker) => TimelineItem::ReadMarker,

            TimelineItemKind::Virtual(VirtualTimelineItem::TimelineStart) => {

                TimelineItem::TimelineStart

            }

            TimelineItemKind::Virtual(VirtualTimelineItem::HistoryGap(gap)) => {

                use matrix_sdk::event_cache::HistoryGapStatus;

                let (lifecycle, failure) = match &gap.status {

                    // the sdk drops joined gaps before they reach a timeline

                    HistoryGapStatus::Idle | HistoryGapStatus::Joined => {

                        (HistoryGapLifecycle::Idle, None)

                    }

                    HistoryGapStatus::Paused => (HistoryGapLifecycle::Paused, None),

                    HistoryGapStatus::Failed { message } => {

                        (HistoryGapLifecycle::Failed, Some(message.clone()))

                    }

                    HistoryGapStatus::Unavailable => (HistoryGapLifecycle::Unavailable, None),

                };

                TimelineItem::HistoryGap(HistoryGap {

                    id: gap.id.clone(),

                    older_boundary: gap.older_boundary.clone(),

                    newer_boundary: gap.newer_boundary.clone(),

                    lifecycle,

                    failure,

                })

            }

        }

    }

    fn event(&mut self, item: &SdkTimelineItem, event: &EventTimelineItem) -> TimelineEvent {

        let msg_like = match event.content() {

            TimelineItemContent::MsgLike(content) => Some(content),

            _ => None,

        };

        let reply_to = msg_like

            .and_then(|content| content.in_reply_to.as_ref())

            .map(|reply| {

                let details = match &reply.event {

                    TimelineDetails::Ready(embedded) => ReplyDetails::Ready {

                        sender: sender(&embedded.sender, &embedded.sender_profile),

                        content: Box::new(content(&embedded.content, None)),

                        timestamp_ms: embedded.timestamp.get().into(),

                    },

                    TimelineDetails::Unavailable => {

                        self.missing_replies.push(reply.event_id.clone());

                        ReplyDetails::Pending

                    }

                    TimelineDetails::Pending => ReplyDetails::Pending,

                    TimelineDetails::Error(_) => ReplyDetails::Unavailable,

                };

                ReplyReference {

                    event_id: reply.event_id.clone(),

                    details,

                }

            });

        let mut read_by: Vec<_> = event

            .read_receipts()

            .keys()

            .filter(|user_id| *user_id != event.sender())

            .cloned()

            .collect();

        read_by.sort();

        TimelineEvent {

            item_id: TimelineItemId::new(item.unique_id().0.clone()),

            event_id: event.event_id().map(ToOwned::to_owned),

            transaction_id: event.transaction_id().map(ToOwned::to_owned),

            sender: sender(event.sender(), event.sender_profile()),

            timestamp_ms: event.timestamp().get().into(),

            own: event.is_own(),

            send_state: send_state(event.send_state()),

            content: content(event.content(), Some(&media_identity(item, self.scope))),

            reply_to,

            thread_root: msg_like.and_then(|content| content.thread_root.clone()),

            thread_summary: msg_like.and_then(thread_summary),

            reactions: reactions(event, self.current_user_id),

            read_by,

            editable: event.is_editable(),

            highlight: event.is_highlighted(),

        }

    }

}

pub(crate) fn normalise_timeline<'a>(

    items: impl Iterator<Item = &'a Arc<SdkTimelineItem>>,

    current_user_id: Option<&UserId>,

    scope: &MediaScope,

) -> NormalisedTimeline {

    let mut normaliser = Normaliser {

        current_user_id,

        scope,

        media: Vec::new(),

        missing_replies: Vec::new(),

    };

    let items = items.map(|item| normaliser.item(item)).collect();

    NormalisedTimeline {

        items,

        media: normaliser.media,

        missing_replies: normaliser.missing_replies,

    }

}

pub(crate) fn normalise_timeline_diffs(

    diffs: Vec<VectorDiff<Arc<SdkTimelineItem>>>,

    current_user_id: Option<&UserId>,

    scope: &MediaScope,

) -> NormalisedTimelineDiffs {

    let mut normaliser = Normaliser {

        current_user_id,

        scope,

        media: Vec::new(),

        missing_replies: Vec::new(),

    };

    let diffs = diffs

        .into_iter()

        .map(|diff| match diff.map(|item| normaliser.item(&item)) {

            VectorDiff::Append { values } => TimelineDiff::Append {

                values: values.into_iter().collect(),

            },

            VectorDiff::Clear => TimelineDiff::Clear,

            VectorDiff::PushFront { value } => TimelineDiff::PushFront { value },

            VectorDiff::PushBack { value } => TimelineDiff::PushBack { value },

            VectorDiff::PopFront => TimelineDiff::PopFront,

            VectorDiff::PopBack => TimelineDiff::PopBack,

            VectorDiff::Insert { index, value } => TimelineDiff::Insert { index, value },

            VectorDiff::Set { index, value } => TimelineDiff::Set { index, value },

            VectorDiff::Remove { index } => TimelineDiff::Remove { index },

            VectorDiff::Truncate { length } => TimelineDiff::Truncate { length },

            VectorDiff::Reset { values } => TimelineDiff::Reset {

                values: values.into_iter().collect(),

            },

        })

        .collect();

    NormalisedTimelineDiffs {

        diffs,

        media: normaliser.media,

        missing_replies: normaliser.missing_replies,

    }

}

/// `media_identity` is `None` for embedded reply content, which never gets fetchable media of its own

fn content(content: &TimelineItemContent, media_identity: Option<&str>) -> TimelineContent {

    match content {

        TimelineItemContent::MsgLike(content) => msg_like(content, media_identity),

        TimelineItemContent::MembershipChange(change) => TimelineContent::Membership {

            user_id: change.user_id().to_owned(),

            display_name: change.display_name(),

            change: change

                .change()

                .map_or(MembershipChange::Other, membership_change),

        },

        TimelineItemContent::ProfileChange(change) => TimelineContent::Profile {

            user_id: change.user_id().to_owned(),

            display_name: change.displayname_change().map(|change| Change {

                old: change.old.clone(),

                new: change.new.clone(),

            }),

            avatar: change.avatar_url_change().map(|change| Change {

                old: change.old.as_deref().map(MediaId::plain),

                new: change.new.as_deref().map(MediaId::plain),

            }),

        },

        TimelineItemContent::OtherState(state) => match state.content() {

            AnyOtherStateEventContentChange::RoomName(change) => TimelineContent::RoomName(

                original(change).and_then(|content| non_empty(&content.name)),

            ),

            AnyOtherStateEventContentChange::RoomTopic(change) => TimelineContent::RoomTopic(

                original(change).and_then(|content| non_empty(&content.topic)),

            ),

            AnyOtherStateEventContentChange::RoomAvatar(change) => TimelineContent::RoomAvatar(

                original(change).and_then(|content| content.url.as_deref().map(MediaId::plain)),

            ),

            AnyOtherStateEventContentChange::RoomEncryption(_) => {

                TimelineContent::EncryptionEnabled

            }

            AnyOtherStateEventContentChange::RoomCreate(_) => TimelineContent::RoomCreated,

            AnyOtherStateEventContentChange::RoomTombstone(change) => match original(change) {

                Some(content) => TimelineContent::RoomUpgraded {

                    successor: content.replacement_room.clone(),

                },

                None => other_state(state.content().event_type().to_string(), state.state_key()),

            },

            other => other_state(other.event_type().to_string(), state.state_key()),

        },

        TimelineItemContent::FailedToParseMessageLike { event_type, .. } => {

            TimelineContent::Other {

                event_type: event_type.to_string(),

            }

        }

        TimelineItemContent::FailedToParseState {

            event_type,

            state_key,

            ..

        } => other_state(event_type.to_string(), state_key),

        TimelineItemContent::CallInvite => TimelineContent::Other {

            event_type: "m.call.invite".to_owned(),

        },

        TimelineItemContent::RtcNotification { .. } => TimelineContent::Other {

            event_type: "org.matrix.msc4075.rtc.notification".to_owned(),

        },

    }

}

/// a cleared name or topic arrives as an empty string

fn non_empty(value: &str) -> Option<String> {

    (!value.is_empty()).then(|| value.to_owned())

}

fn other_state(event_type: String, state_key: &str) -> TimelineContent {

    TimelineContent::OtherState {

        event_type,

        state_key: state_key.to_owned(),

    }

}

fn original<C>(change: &StateEventContentChange<C>) -> Option<&C>

where

    C: ruma::events::StaticStateEventContent + ruma::events::RedactContent,

{

    match change {

        StateEventContentChange::Original { content, .. } => Some(content),

        StateEventContentChange::Redacted(_) => None,

    }

}

fn msg_like(content: &MsgLikeContent, media_identity: Option<&str>) -> TimelineContent {

    match &content.kind {

        MsgLikeKind::Message(message) => TimelineContent::Message(Message {

            kind: message_kind(message.msgtype()),

            body: message.body().to_owned(),

            geo_uri: match message.msgtype() {

                MessageType::Location(location) => Some(location.geo_uri.clone()),

                _ => None,

            },

            formatted_body: formatted_body(message.msgtype()),

            mentions: message.mentions().map(|mentions| MessageMentions {

                user_ids: mentions.user_ids.iter().cloned().collect(),

                room: mentions.room,

            }),

            edited: message.is_edited(),

            media: media_identity

                .and_then(|identity| media_from_message(identity, message.msgtype())),

            link_previews: sender_previews(media_identity, message.msgtype())

                .into_iter()

                .map(|(preview, _)| preview)

                .collect(),

        }),

        MsgLikeKind::Sticker(sticker) => {

            let sticker = sticker.content();

            match media_identity {

                Some(identity) => TimelineContent::Sticker {

                    body: sticker.body.clone(),

                    media: media_descriptor_for_sticker(identity, sticker),

                },

                None => TimelineContent::Other {

                    event_type: "m.sticker".to_owned(),

                },

            }

        }

        MsgLikeKind::Poll(poll) => TimelineContent::Poll {

            question: poll.results().question,

        },

        MsgLikeKind::Redacted => TimelineContent::Redacted,

        MsgLikeKind::UnableToDecrypt(encrypted) => {

            TimelineContent::UnableToDecrypt(match encrypted {

                EncryptedMessage::MegolmV1AesSha2 { cause, .. } => utd_cause(*cause),

                _ => UtdCause::Unknown,

            })

        }

        MsgLikeKind::Other(other) => TimelineContent::Other {

            event_type: other.event_type().to_string(),

        },

        MsgLikeKind::LiveLocation(_) => TimelineContent::Other {

            event_type: "m.beacon_info".to_owned(),

        },

    }

}

pub(crate) fn message_kind(message: &MessageType) -> MessageKind {

    match message {

        MessageType::Text(_) => MessageKind::Text,

        MessageType::Emote(_) => MessageKind::Emote,

        MessageType::Notice(_) => MessageKind::Notice,

        MessageType::ServerNotice(_) => MessageKind::ServerNotice,

        MessageType::Image(_) => MessageKind::Image,

        MessageType::Video(_) => MessageKind::Video,

        MessageType::Audio(_) => MessageKind::Audio,

        MessageType::File(_) => MessageKind::File,

        MessageType::Location(_) => MessageKind::Location,

        MessageType::VerificationRequest(_) => MessageKind::VerificationRequest,

        other => MessageKind::Other(other.msgtype().to_owned()),

    }

}

const fn membership_change(change: SdkMembershipChange) -> MembershipChange {

    match change {

        SdkMembershipChange::Joined => MembershipChange::Joined,

        SdkMembershipChange::Left => MembershipChange::Left,

        SdkMembershipChange::Banned => MembershipChange::Banned,

        SdkMembershipChange::Unbanned => MembershipChange::Unbanned,

        SdkMembershipChange::Kicked => MembershipChange::Kicked,

        SdkMembershipChange::KickedAndBanned => MembershipChange::KickedAndBanned,

        SdkMembershipChange::Invited => MembershipChange::Invited,

        SdkMembershipChange::InvitationAccepted => MembershipChange::InvitationAccepted,

        SdkMembershipChange::InvitationRejected => MembershipChange::InvitationRejected,

        SdkMembershipChange::InvitationRevoked => MembershipChange::InvitationRevoked,

        SdkMembershipChange::Knocked => MembershipChange::Knocked,

        SdkMembershipChange::KnockAccepted => MembershipChange::KnockAccepted,

        SdkMembershipChange::KnockRetracted => MembershipChange::KnockRetracted,

        SdkMembershipChange::KnockDenied => MembershipChange::KnockDenied,

        SdkMembershipChange::None

        | SdkMembershipChange::Error

        | SdkMembershipChange::NotImplemented => MembershipChange::Other,

    }

}

const fn utd_cause(cause: SdkUtdCause) -> UtdCause {

    match cause {

        SdkUtdCause::Unknown => UtdCause::Unknown,

        SdkUtdCause::SentBeforeWeJoined => UtdCause::SentBeforeWeJoined,

        SdkUtdCause::VerificationViolation => UtdCause::VerificationViolation,

        SdkUtdCause::UnsignedDevice => UtdCause::UnsignedDevice,

        SdkUtdCause::UnknownDevice => UtdCause::UnknownDevice,

        SdkUtdCause::HistoricalMessageAndBackupIsDisabled => {

            UtdCause::HistoricalMessageAndBackupIsDisabled

        }

        SdkUtdCause::WithheldForUnverifiedOrInsecureDevice => {

            UtdCause::WithheldForUnverifiedOrInsecureDevice

        }

        SdkUtdCause::WithheldBySender => UtdCause::WithheldBySender,

        SdkUtdCause::HistoricalMessageAndDeviceIsUnverified => {

            UtdCause::HistoricalMessageAndDeviceIsUnverified

        }

    }

}

fn sender(user_id: &UserId, profile: &TimelineDetails<Profile>) -> Sender {

    let profile = match profile {

        TimelineDetails::Ready(profile) => Some(profile),

        _ => None,

    };

    Sender {

        user_id: user_id.to_owned(),

        display_name: profile.and_then(|profile| profile.display_name.clone()),

        avatar: profile.and_then(|profile| profile.avatar_url.as_deref().map(MediaId::plain)),

        name_ambiguous: profile.is_some_and(|profile| profile.display_name_ambiguous),

    }

}

fn send_state(state: Option<&EventSendState>) -> SendState {

    match state {

        None | Some(EventSendState::Sent { .. }) => SendState::Sent,

        Some(EventSendState::NotSentYet { .. }) => SendState::Sending,

        // recoverable means the sdk parks the queue and we unpark it, nothing for the user to do

        Some(EventSendState::SendingFailed { is_recoverable, .. }) => SendState::Failed {

            will_retry: *is_recoverable,

        },

    }

}

fn thread_summary(content: &MsgLikeContent) -> Option<ThreadSummary> {

    content.thread_summary.as_ref().map(|summary| {

        let latest_event = match &summary.latest_event {

            TimelineDetails::Ready(event) => Some(event.as_ref()),

            _ => None,

        };

        ThreadSummary {

            reply_count: summary.num_replies,

            latest_event_id: latest_event.and_then(|event| match &event.identifier {

                TimelineEventItemId::EventId(event_id) => Some(event_id.clone()),

                TimelineEventItemId::TransactionId(_) => None,

            }),

            latest_event_timestamp_ms: latest_event.map(|event| event.timestamp.get().into()),

        }

    })

}

fn reactions(event: &EventTimelineItem, current_user_id: Option<&UserId>) -> Vec<Reaction> {

    event

        .content()

        .reactions()

        .into_iter()

        .flat_map(|reactions| reactions.iter())

        .map(|(key, senders)| Reaction {

            key: key.clone(),

            shortcode: senders.values().find_map(|info| info.shortcode.clone()),

            image: <&MxcUri>::from(key.as_str())

                .is_valid()

                .then(|| MediaId::plain(key)),

            count: senders.len(),

            own: current_user_id.is_some_and(|user_id| senders.contains_key(user_id)),

            senders: senders.keys().cloned().collect(),

        })

        .collect()

}

pub(super) fn formatted_body(message: &MessageType) -> Option<String> {

    let formatted = match message {