macltok

use std::collections::HashMap;

use ruma::{MxcUri, OwnedEventId, OwnedUserId, RoomId, UserId};

use serde_json::Value;

use super::{media::MediaRegistration, observed::normalise_observed};

use crate::{MediaId, Reaction, ReplyDetails, Sender, TimelineEvent, TimelineItem};

pub(crate) struct ContextPage {

    /// each with the index of the raw event it came from

    pub(crate) items: Vec<(usize, TimelineItem)>,

    pub(crate) media: Vec<MediaRegistration>,

}

struct Annotation<'a> {

    key: &'a str,

    sender: &'a str,

    shortcode: Option<&'a str>,

}

/// raw events in timeline order, shown the way the live room timeline shows them. edits and

/// reactions fold into their targets within the page, and redactions, unmatched relations

/// and thread replies go. `keep` is never dropped. `media_prefix` keeps one owner's media ids

/// apart from another's for the same event

pub(crate) fn normalise_context(

    values: &[Value],

    keep: Option<usize>,

    current_user_id: Option<&UserId>,

    room_id: &RoomId,

    media_prefix: &str,

) -> ContextPage {

    let mut edits: HashMap<&str, Vec<&Value>> = HashMap::new();

    let mut annotations: HashMap<&str, Vec<Annotation<'_>>> = HashMap::new();

    let mut shown = Vec::new();

    for (index, value) in values.iter().enumerate() {

        let str_at = |pointer: &str| value.pointer(pointer).and_then(Value::as_str);

        let target = str_at("/content/m.relates_to/event_id");

        if Some(index) == keep {

            shown.push(index);

            continue;

        }

        match (

            str_at("/type"),

            str_at("/content/m.relates_to/rel_type"),

            target,

        ) {

            (Some("m.room.redaction"), ..) => {}

            (Some("m.reaction"), Some("m.annotation"), Some(target)) => {

                if let (Some(key), Some(sender)) =

                    (str_at("/content/m.relates_to/key"), str_at("/sender"))

                {

                    annotations.entry(target).or_default().push(Annotation {

                        key,

                        sender,

                        shortcode: str_at("/content/com.beeper.reaction.shortcode")

                            .or_else(|| str_at("/content/shortcode")),

                    });

                }

            }

            (Some("m.reaction"), ..) => {}

            // an edit still encrypted keeps its relation in the clear but has no new content

            (_, Some("m.replace"), Some(target)) => {

                if value.pointer("/content/m.new_content").is_some() {

                    edits.entry(target).or_default().push(value);

                }

            }

            (_, Some("m.thread"), _) => {}

            _ => shown.push(index),

        }

    }

    let mut media = Vec::new();

    let items = shown

        .into_iter()

        .filter_map(|index| {

            let mut value = std::borrow::Cow::Borrowed(&values[index]);

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

            let latest_edit = edits.get(event_id.as_str()).and_then(|edits| {

                edits

                    .iter()

                    .rev()

                    .find(|edit| edit.get("sender") == value.get("sender"))

            });

            if let Some(edit) = latest_edit.copied()

                && value.pointer("/unsigned/m.relations/m.replace").is_none()

            {

                let unsigned = value

                    .to_mut()

                    .as_object_mut()?

                    .entry("unsigned")

                    .or_insert_with(|| Value::Object(Default::default()));

                let relations = unsigned

                    .as_object_mut()?

                    .entry("m.relations")

                    .or_insert_with(|| Value::Object(Default::default()));

                relations

                    .as_object_mut()?

                    .insert("m.replace".to_owned(), edit.clone());

            }

            let identity = format!("{media_prefix}{room_id}\n{event_id}");

            let (mut item, registrations) = normalise_observed(&value, current_user_id, &identity)?;

            media.extend(registrations);

            if let (TimelineItem::Event(event), Some(annotations)) =

                (&mut item, annotations.get(event_id.as_str()))

            {

                event.reactions = reactions(annotations, current_user_id);

            }

            Some((index, item))

        })

        .collect();

    ContextPage { items, media }

}

fn reactions(annotations: &[Annotation<'_>], current_user_id: Option<&UserId>) -> Vec<Reaction> {

    let mut reactions: Vec<Reaction> = Vec::new();

    for annotation in annotations {

        let Ok(sender) = OwnedUserId::try_from(annotation.sender) else {

            continue;

        };

        let index = match reactions.iter().position(|r| r.key == annotation.key) {

            Some(index) => index,

            None => {

                reactions.push(Reaction {

                    key: annotation.key.to_owned(),

                    shortcode: None,

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

                        .is_valid()

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

                    count: 0,

                    own: false,

                    senders: Vec::new(),

                });

                reactions.len() - 1

            }

        };

        let reaction = &mut reactions[index];

        if reaction.senders.contains(&sender) {

            continue;

        }

        reaction.own |= current_user_id == Some(sender.as_ref());

        reaction.senders.push(sender);

        reaction.count = reaction.senders.len();

        if reaction.shortcode.is_none() {

            reaction.shortcode = annotation.shortcode.map(str::to_owned);

        }

    }

    reactions

}

/// the sender's member data, for each event and every reply quoted in it

pub(crate) fn apply_profiles<'a>(

    events: impl Iterator<Item = &'a mut TimelineEvent>,

    profiles: &HashMap<OwnedUserId, Sender>,

) {

    for event in events {

        if let Some(sender) = profiles.get(&event.sender.user_id) {

            event.sender = sender.clone();

        }

    }

}

/// settles every reply, from `targets` or as unavailable

pub(crate) fn resolve_replies<'a>(

    events: impl Iterator<Item = &'a mut TimelineEvent>,

    targets: &HashMap<OwnedEventId, TimelineEvent>,

) {

    for event in events {

        let Some(reply) = event.reply_to.as_mut() else {

            continue;

        };

        if !matches!(reply.details, ReplyDetails::Pending) {

            continue;

        }

        reply.details = match targets.get(&reply.event_id) {

            Some(target) => ReplyDetails::Ready {

                sender: target.sender.clone(),

                content: Box::new(target.content.clone()),

                timestamp_ms: target.timestamp_ms,

            },

            None => ReplyDetails::Unavailable,

        };

    }

}

#[cfg(test)]

mod tests {

    use ruma::{room_id, user_id};

    use serde_json::json;

    use super::*;

    use crate::TimelineContent;

    fn message(id: &str, sender: &str, body: &str) -> Value {

        json!({

            "type": "m.room.message",

            "event_id": id,

            "sender": sender,

            "origin_server_ts": 1,

            "content": { "msgtype": "m.text", "body": body },

        })

    }

    #[test]

    fn edits_and_reactions_fold_into_their_targets() {

        let mut edit = message("$edit", "@a:x", "* fixed");

        edit["content"]["m.new_content"] = json!({ "msgtype": "m.text", "body": "fixed" });

        edit["content"]["m.relates_to"] = json!({ "rel_type": "m.replace", "event_id": "$orig" });

        let mut foreign_edit = message("$foreign", "@b:x", "* hijack");

        foreign_edit["content"]["m.new_content"] = json!({ "msgtype": "m.text", "body": "hijack" });

        foreign_edit["content"]["m.relates_to"] =

            json!({ "rel_type": "m.replace", "event_id": "$orig" });

        let reaction = |id: &str, sender: &str| {

            json!({

                "type": "m.reaction",

                "event_id": id,

                "sender": sender,

                "origin_server_ts": 1,

                "content": { "m.relates_to": {

                    "rel_type": "m.annotation", "event_id": "$orig", "key": "👍",

                }},

            })

        };

        let mut threaded = message("$threaded", "@b:x", "in a thread");

        threaded["content"]["m.relates_to"] =

            json!({ "rel_type": "m.thread", "event_id": "$orig" });

        let values = [

            message("$orig", "@a:x", "typo"),

            edit,

            foreign_edit,

            reaction("$r1", "@b:x"),

            reaction("$r2", "@b:x"),

            reaction("$r3", "@a:x"),

            threaded,

            json!({

                "type": "m.room.redaction",

                "event_id": "$redaction",

                "sender": "@a:x",

                "origin_server_ts": 1,

                "redacts": "$gone",

                "content": {},

            }),

        ];

        let page = normalise_context(

            &values,

            None,

            Some(user_id!("@a:x")),

            room_id!("!room:x"),

            "",

        );

        assert_eq!(page.items.len(), 1);

        let TimelineItem::Event(event) = &page.items[0].1 else {

            panic!("expected an event");

        };

        let TimelineContent::Message(message) = &event.content else {

            panic!("expected a message");

        };

        assert_eq!(message.body, "fixed");

        assert!(message.edited);

        assert_eq!(event.reactions.len(), 1);

        assert_eq!(event.reactions[0].count, 2);

        assert!(event.reactions[0].own);

    }

}