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<'_> {

    /// `None` for rows macltok leaves out

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

        if let TimelineItemKind::Virtual(VirtualTimelineItem::HistoryGap(gap)) = item.kind()

            && gap.status == matrix_sdk::event_cache::HistoryGapStatus::Joined

        {

            return None;

        }

        self.media

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

        Some(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 {

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

        }

    }

}

pub(crate) fn normalise_timeline<'a>(

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

    current_user_id: Option<&UserId>,

    scope: &MediaScope,

) -> (NormalisedTimeline, HiddenRows) {

    let mut normaliser = Normaliser {

        current_user_id,

        scope,

        media: Vec::new(),

        missing_replies: Vec::new(),

    };

    let mut hidden = HiddenRows::default();

    let items = hidden.reset(items.map(|item| normaliser.item(item)));

    let normalised = NormalisedTimeline {

        items: items.into_iter().collect(),

        media: normaliser.media,

        missing_replies: normaliser.missing_replies,

    };

    (normalised, hidden)

}

pub(crate) fn normalise_timeline_diffs(

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

    current_user_id: Option<&UserId>,

    scope: &MediaScope,

    hidden: &mut HiddenRows,

) -> NormalisedTimelineDiffs {

    let mut normaliser = Normaliser {

        current_user_id,

        scope,

        media: Vec::new(),

        missing_replies: Vec::new(),

    };

    let diffs = diffs

        .into_iter()

        .filter_map(|diff| hidden.translate(diff.map(|item| normaliser.item(&item))))

        .collect();

    NormalisedTimelineDiffs {

        diffs,

        media: normaliser.media,

        missing_replies: normaliser.missing_replies,

    }

}

/// which sdk rows were left out, so diff indices can step over them

#[derive(Default)]

pub(crate) struct HiddenRows {

    rows: imbl::Vector<bool>,

    hidden: usize,

}

impl HiddenRows {

    fn visible_index(&self, index: usize) -> usize {

        if self.hidden == 0 {

            return index;

        }

        self.rows

            .iter()

            .take(index)

            .filter(|hidden| !**hidden)

            .count()

    }

    fn push(&mut self, front: bool, item: &Option<TimelineItem>) {

        self.hidden += usize::from(item.is_none());

        if front {

            self.rows.push_front(item.is_none());

        } else {

            self.rows.push_back(item.is_none());

        }

    }

    fn forget(&mut self, hidden: bool) -> bool {

        self.hidden -= usize::from(hidden);

        !hidden

    }

    fn reset(&mut self, items: impl Iterator<Item = Option<TimelineItem>>) -> Vec<TimelineItem> {

        *self = Self::default();

        items

            .filter_map(|item| {

                self.push(false, &item);

                item

            })

            .collect()

    }

    fn translate(&mut self, diff: VectorDiff<Option<TimelineItem>>) -> Option<TimelineDiff> {

        Some(match diff {

            VectorDiff::Append { values } => {

                let values: Vec<_> = values

                    .into_iter()

                    .filter_map(|item| {

                        self.push(false, &item);

                        item

                    })

                    .collect();

                if values.is_empty() {

                    return None;

                }

                TimelineDiff::Append { values }

            }

            VectorDiff::Clear => {

                *self = Self::default();

                TimelineDiff::Clear

            }

            VectorDiff::PushFront { value } => {

                self.push(true, &value);

                TimelineDiff::PushFront { value: value? }

            }

            VectorDiff::PushBack { value } => {

                self.push(false, &value);

                TimelineDiff::PushBack { value: value? }

            }

            VectorDiff::PopFront => {

                let hidden = self.rows.pop_front()?;

                self.forget(hidden).then_some(TimelineDiff::PopFront)?

            }

            VectorDiff::PopBack => {

                let hidden = self.rows.pop_back()?;

                self.forget(hidden).then_some(TimelineDiff::PopBack)?

            }

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

                let visible = self.visible_index(index);

                self.hidden += usize::from(value.is_none());

                self.rows.insert(index, value.is_none());

                TimelineDiff::Insert {

                    index: visible,

                    value: value?,

                }

            }

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

                let visible = self.visible_index(index);

                let was_hidden = self.rows.set(index, value.is_none());

                self.hidden = self.hidden + usize::from(value.is_none()) - usize::from(was_hidden);

                match (was_hidden, value) {

                    (false, Some(value)) => TimelineDiff::Set {

                        index: visible,

                        value,

                    },

                    (false, None) => TimelineDiff::Remove { index: visible },

                    (true, Some(value)) => TimelineDiff::Insert {

                        index: visible,

                        value,

                    },

                    (true, None) => return None,

                }

            }

            VectorDiff::Remove { index } => {

                let visible = self.visible_index(index);

                let hidden = self.rows.remove(index);

                self.forget(hidden)

                    .then_some(TimelineDiff::Remove { index: visible })?

            }

            VectorDiff::Truncate { length } => {

                let visible = self.visible_index(length);

                let dropped = self

                    .rows

                    .iter()

                    .skip(length)

                    .filter(|hidden| **hidden)

                    .count();

                self.hidden -= dropped;

                self.rows.truncate(length);

                TimelineDiff::Truncate { length: visible }

            }

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

                values: self.reset(values.into_iter()),

            },

        })

    }

}

/// `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,