macltok

use std::sync::Arc;

use matrix_sdk_ui::{

    eyeball_im::VectorDiff,

    timeline::{

        EventSendState, MsgLikeKind, TimelineDetails, TimelineEventItemId,

        TimelineItem as SdkTimelineItem, TimelineItemContent, TimelineItemKind,

        VirtualTimelineItem,

    },

};

use ruma::{

    UserId,

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

};

use crate::{

    MessageMentions, Reaction, ReplyReference, SendState, ThreadSummary, TimelineDiff,

    TimelineItem, TimelineItemId, TimelineMessage,

};

use super::media::{

    MediaRegistration, MediaScope, media_descriptor_for_sticker, media_from_message,

    media_identity, media_registration_for_item,

};

pub(crate) struct NormalisedTimeline {

    pub(crate) items: Vec<TimelineItem>,

    pub(crate) media: Vec<MediaRegistration>,

}

pub(crate) fn normalise_timeline<'a>(

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

    current_user_id: Option<&UserId>,

    scope: &MediaScope,

) -> NormalisedTimeline {

    let mut normalised = NormalisedTimeline {

        items: Vec::new(),

        media: Vec::new(),

    };

    for item in items {

        if let Some(media) = media_registration_for_item(item, scope) {

            normalised.media.push(media);

        }

        normalised

            .items

            .push(normalise_timeline_item(item, current_user_id, scope));

    }

    normalised

}

pub(crate) fn normalise_timeline_diffs(

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

    current_user_id: Option<&UserId>,

    scope: &MediaScope,

) -> NormalisedTimelineDiffs {

    let mut media = Vec::new();

    let diffs = diffs

        .into_iter()

        .map(|diff| {

            let diff = diff.map(|item| {

                if let Some(registration) = media_registration_for_item(&item, scope) {

                    media.push(registration);

                }

                normalise_timeline_item(&item, current_user_id, scope)

            });

            match diff {

                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 }

}

pub(crate) struct NormalisedTimelineDiffs {

    pub(crate) diffs: Vec<TimelineDiff>,

    pub(crate) media: Vec<MediaRegistration>,

}

fn normalise_timeline_item(

    item: &SdkTimelineItem,

    current_user_id: Option<&UserId>,

    scope: &MediaScope,

) -> TimelineItem {

    match item.kind() {

        TimelineItemKind::Event(event) => TimelineItem::Message(Box::new(timeline_message(

            item,

            event,

            current_user_id,

            scope,

        ))),

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

            TimelineItem::DayDivider {

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

            }

        }

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

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

            TimelineItem::TimelineStart

        }

    }

}

fn timeline_message(

    item: &SdkTimelineItem,

    event: &matrix_sdk_ui::timeline::EventTimelineItem,

    current_user_id: Option<&UserId>,

    scope: &MediaScope,

) -> TimelineMessage {

    let (body, formatted_body, mentions, edited, unable_to_decrypt, media) = match event.content() {

        TimelineItemContent::MsgLike(content) => match &content.kind {

            MsgLikeKind::Message(message) => (

                message.body().to_owned(),

                formatted_body(message.msgtype()),

                message.mentions().map(message_mentions),

                message.is_edited(),

                false,

                media_from_message(&media_identity(item, scope), message.msgtype()),

            ),

            MsgLikeKind::Sticker(sticker) => {

                let content = sticker.content();

                (

                    content.body.clone(),

                    None,

                    None,

                    false,

                    false,

                    Some(media_descriptor_for_sticker(

                        &media_identity(item, scope),

                        content,

                    )),

                )

            }

            MsgLikeKind::Redacted => ("<message redacted>".into(), None, None, false, false, None),

            MsgLikeKind::UnableToDecrypt(_) => (

                "<unable to decrypt message>".into(),

                None,

                None,

                false,

                true,

                None,

            ),

            MsgLikeKind::Poll(_) => ("[poll]".into(), None, None, false, false, None),

            MsgLikeKind::LiveLocation(_) => {

                ("[live location]".into(), None, None, false, false, None)

            }

            MsgLikeKind::Other(other) => (

                format!("[{}]", other.event_type()),

                None,

                None,

                false,

                false,

                None,

            ),

        },

        other => (

            format!(

                "[{}]",

                other.event_type_str().unwrap_or_else(|| "event".into())

            ),

            None,

            None,

            false,

            false,

            None,

        ),

    };

    let reply_to = match event.content() {

        TimelineItemContent::MsgLike(content) => content.in_reply_to.as_ref().map(|reply| {

            let event_id = reply.event_id.to_owned();

            let embedded_sender = match &reply.event {

                TimelineDetails::Ready(event) => Some((

                    event.sender.clone(),

                    sender_name(&event.sender, &event.sender_profile),

                )),

                _ => None,

            };

            ReplyReference {

                event_id,

                sender_id: embedded_sender.as_ref().map(|(id, _)| id.clone()),

                sender_name: embedded_sender.map(|(_, name)| name),

            }

        }),

        _ => None,

    };

    let (thread_root, thread_summary) = match event.content() {

        TimelineItemContent::MsgLike(content) => (

            content.thread_root.clone(),

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

                }

            }),

        ),

        _ => (None, None),

    };

    let reactions = event

        .content()

        .reactions()

        .into_iter()

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

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

            key: key.clone(),

            count: senders.len(),

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

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

        })

        .collect();

    let mut read_by: Vec<_> = event

        .read_receipts()

        .keys()

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

        .cloned()

        .collect();

    read_by.sort();

    TimelineMessage {

        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_id: event.sender().to_owned(),

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

        body,

        formatted_body,

        mentions,

        thread_root,

        thread_summary,

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

        own: event.is_own(),

        send_state: match event.send_state() {

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

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

            Some(EventSendState::NotSentYet { progress: None }) => SendState::Queued,

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

                retriable: *is_recoverable,

            },

        },

        edited,

        unable_to_decrypt,

        media,

        reply_to,

        reactions,

        read_by,

    }

}

fn sender_name(

    sender: &UserId,

    sender_profile: &TimelineDetails<matrix_sdk_ui::timeline::Profile>,

) -> String {

    match sender_profile {

        TimelineDetails::Ready(profile) => profile

            .display_name

            .clone()

            .unwrap_or_else(|| sender.to_string()),

        _ => sender.to_string(),

    }

}

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

    let formatted = match message {

        MessageType::Text(content) => content.formatted.as_ref(),

        MessageType::Emote(content) => content.formatted.as_ref(),

        MessageType::Notice(content) => content.formatted.as_ref(),

        MessageType::Audio(content) => content.formatted_caption(),

        MessageType::File(content) => content.formatted_caption(),

        MessageType::Image(content) => content.formatted_caption(),

        MessageType::Video(content) => content.formatted_caption(),

        _ => None,

    }?;

    (formatted.format == MessageFormat::Html).then(|| formatted.body.clone())

}

fn message_mentions(mentions: &ruma::events::Mentions) -> MessageMentions {

    MessageMentions {

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

        room: mentions.room,

    }

}