macltok

use ruma::{

    OwnedEventId, UserId,

    events::{

        poll::{start::PollStartEventContent, unstable_start::UnstablePollStartEventContent},

        room::message::{

            MessageType, Relation, RoomMessageEventContent, RoomMessageEventContentWithoutRelation,

        },

        sticker::StickerEventContent,

    },

};

use serde_json::Value;

use super::{

    link_preview::sender_previews,

    media::{

        MediaRegistration, media_descriptor_for_sticker, media_registration,

        media_sticker_registration,

    },

    timeline::formatted_body,

};

use crate::{

    Message, MessageMentions, ReplyDetails, ReplyReference, SendState, Sender, TimelineContent,

    TimelineEvent, TimelineItem, TimelineItemId, UtdCause,

};

pub(crate) fn normalise_observed(

    value: &Value,

    current_user_id: Option<&UserId>,

    identity: &str,

) -> Option<(TimelineItem, Vec<MediaRegistration>)> {

    let event_id: OwnedEventId = serde_json::from_value(value.get("event_id")?.clone()).ok()?;

    let sender_id: ruma::OwnedUserId = serde_json::from_value(value.get("sender")?.clone()).ok()?;

    let timestamp_ms = value.get("origin_server_ts")?.as_u64()?;

    let event_type = value.get("type")?.as_str()?.to_owned();

    let own = current_user_id.is_some_and(|user_id| user_id.as_str() == sender_id.as_str());

    let redacted = value

        .get("unsigned")

        .and_then(|unsigned| unsigned.get("redacted_because"))

        .is_some();

    let mut media = Vec::new();

    let (content, reply_to, thread_root) = if redacted {

        (TimelineContent::Redacted, None, None)

    } else if event_type == "m.room.message" {

        match value

            .get("content")

            .cloned()

            .and_then(|content| serde_json::from_value::<RoomMessageEventContent>(content).ok())

        {

            Some(mut message) => {

                let (reply_to, thread_root) = relation_refs(message.relates_to.as_ref());

                let relation_replacement = match &message.relates_to {

                    Some(Relation::Replacement(replacement)) => {

                        Some(replacement.new_content.clone())

                    }

                    _ => None,

                };

                let bundled_replacement = value

                    .get("unsigned")

                    .and_then(|unsigned| unsigned.get("m.relations"))

                    .and_then(|relations| relations.get("m.replace"))

                    .and_then(|edit| {

                        let edit_sender = edit.get("sender")?.as_str()?;

                        if edit_sender != sender_id.as_str() {

                            return None;

                        }

                        edit.get("content")?.get("m.new_content").cloned()

                    })

                    .and_then(|content| {

                        serde_json::from_value::<RoomMessageEventContentWithoutRelation>(content)

                            .ok()

                    });

                let edited = relation_replacement.is_some()

                    || bundled_replacement.is_some()

                    || value

                        .get("unsigned")

                        .and_then(|unsigned| unsigned.get("macltok_edited"))

                        .and_then(Value::as_bool)

                        .unwrap_or(false);

                if let Some(replacement) = relation_replacement.or(bundled_replacement) {

                    message.apply_replacement(replacement);

                }

                let message_type = &message.msgtype;

                media.extend(media_registration(identity, message_type));

                let previews = sender_previews(Some(identity), message_type);

                media.extend(

                    previews

                        .iter()

                        .filter_map(|(_, registration)| registration.clone()),

                );

                (

                    TimelineContent::Message(Message {

                        kind: super::message_kind(message_type),

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

                        geo_uri: match message_type {

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

                            _ => None,

                        },

                        formatted_body: formatted_body(message_type),

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

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

                            room: mentions.room,

                        }),

                        edited,

                        media: super::media::media_from_message(identity, message_type),

                        link_previews: previews.into_iter().map(|(preview, _)| preview).collect(),

                    }),

                    reply_to,

                    thread_root,

                )

            }

            None => (TimelineContent::Other { event_type }, None, None),

        }

    } else if event_type == "m.room.encrypted" {

        (

            TimelineContent::UnableToDecrypt(UtdCause::Unknown),

            None,

            None,

        )

    } else if event_type == "m.sticker" {

        match value

            .get("content")

            .cloned()

            .and_then(|content| serde_json::from_value::<StickerEventContent>(content).ok())

        {

            Some(sticker) => {

                let (reply_to, thread_root) = relation_refs(sticker.relates_to.as_ref());

                media.extend(media_sticker_registration(identity, &sticker));

                (

                    TimelineContent::Sticker {

                        body: sticker.body.clone(),

                        media: media_descriptor_for_sticker(identity, &sticker),

                    },

                    reply_to,

                    thread_root,

                )

            }

            None => (TimelineContent::Other { event_type }, None, None),

        }

    } else if event_type == "m.poll.start" || event_type == "org.matrix.msc3381.poll.start" {

        let poll_content = value.get("content");

        let question = poll_content.and_then(|content| poll_question(content, &event_type));

        match question {

            Some(question) => {

                let (reply_to, thread_root) =

                    poll_content.map(raw_relation_refs).unwrap_or_default();

                (TimelineContent::Poll { question }, reply_to, thread_root)

            }

            None => (TimelineContent::Other { event_type }, None, None),

        }

    } else if let Some(state_key) = value.get("state_key").and_then(Value::as_str) {

        (

            TimelineContent::OtherState {

                event_type,

                state_key: state_key.to_owned(),

            },

            None,

            None,

        )

    } else {

        (TimelineContent::Other { event_type }, None, None)

    };

    let event = TimelineEvent {

        item_id: TimelineItemId::new(identity.to_owned()),

        event_id: Some(event_id),

        transaction_id: None,

        sender: Sender {

            user_id: sender_id,

            display_name: None,

            avatar: None,

            name_ambiguous: false,

        },

        timestamp_ms,

        own,

        send_state: SendState::Sent,

        content,

        reply_to: reply_to.map(|event_id| ReplyReference {

            event_id,

            details: ReplyDetails::Pending,

        }),

        thread_root,

        thread_summary: None,

        reactions: Vec::new(),

        read_by: Vec::new(),

        editable: false,

    };

    Some((TimelineItem::Event(Box::new(event)), media))

}

fn relation_refs<C>(

    relation: Option<&Relation<C>>,

) -> (Option<OwnedEventId>, Option<OwnedEventId>) {

    match relation {

        Some(Relation::Reply(reply)) => (Some(reply.in_reply_to.event_id.clone()), None),

        Some(Relation::Thread(thread)) => (

            thread

                .in_reply_to

                .as_ref()

                .map(|reply| reply.event_id.clone()),

            Some(thread.event_id.clone()),

        ),

        _ => (None, None),

    }

}

fn raw_relation_refs(content: &Value) -> (Option<OwnedEventId>, Option<OwnedEventId>) {

    let Some(relation) = content.get("m.relates_to") else {

        return (None, None);

    };

    let reply_to = relation

        .get("m.in_reply_to")

        .and_then(|reply| reply.get("event_id"))

        .and_then(Value::as_str)

        .and_then(|event_id| event_id.parse().ok());

    let thread_root = (relation.get("rel_type").and_then(Value::as_str) == Some("m.thread"))

        .then(|| relation.get("event_id").and_then(Value::as_str))

        .flatten()

        .and_then(|event_id| event_id.parse().ok());

    (reply_to, thread_root)

}

fn poll_question(content: &Value, event_type: &str) -> Option<String> {

    let typed_question = match event_type {

        "m.poll.start" => serde_json::from_value::<PollStartEventContent>(content.clone())

            .ok()

            .and_then(|poll| poll.poll.question.text.find_plain().map(str::to_owned)),

        "org.matrix.msc3381.poll.start" => {

            serde_json::from_value::<UnstablePollStartEventContent>(content.clone())

                .ok()

                .map(|poll| poll.poll_start().question.text.clone())

        }

        _ => None,

    };

    typed_question

        .or_else(|| {

            content

                .get("m.poll")

                .and_then(|poll| poll.get("question"))

                .and_then(|question| question.get("m.text"))

                .and_then(generic_text)

        })

        .or_else(|| {

            content

                .get("org.matrix.msc3381.poll.start")

                .and_then(|poll| poll.get("question"))

                .and_then(|question| question.get("org.matrix.msc1767.text"))

                .and_then(generic_text)

        })

        .or_else(|| {

            ["org.matrix.msc1767.text", "m.text", "question", "body"]

                .iter()

                .find_map(|key| content.get(*key).and_then(generic_text))

        })

}

fn generic_text(value: &Value) -> Option<String> {

    match value {

        Value::String(text) => Some(text.clone()),

        Value::Array(representations) => representations

            .iter()

            .find(|representation| {

                representation.get("mimetype").and_then(Value::as_str) == Some("text/plain")

            })

            .or_else(|| representations.first())

            .and_then(|representation| representation.get("body"))

            .and_then(Value::as_str)

            .map(str::to_owned),

        Value::Object(_) => value.get("body").and_then(Value::as_str).map(str::to_owned),

        _ => None,

    }

}