macltok

use std::collections::{HashSet, VecDeque};

use ruma::events::room::message::sanitize::remove_plain_reply_fallback;

use serde_json::Value;

use super::{

    MessageIndex,

    index::{Doc, provisional_key},

};

use crate::normalise::poll_question;

const REMEMBERED_REDACTIONS: usize = 10_000;

#[derive(Clone, Debug, Eq, PartialEq)]

pub(crate) struct Edit {

    pub(crate) id: String,

    pub(crate) target: String,

    pub(crate) sender: String,

    pub(crate) ts: u64,

    pub(crate) text: String,

}

#[derive(Clone, Debug, Eq, PartialEq)]

pub(crate) enum Observed {

    Message {

        key: String,

        sender: String,

        ts: u64,

        text: String,

        bundled: Option<Edit>,

    },

    Edit(Edit),

    Redaction {

        target: String,

    },

    Redacted {

        key: String,

    },

    Encrypted {

        key: String,

        session_id: String,

        ts: u64,

    },

    Other,

}

#[derive(Debug, Eq, PartialEq)]

pub(crate) enum Effect {

    Indexed(u64),

    Removed,

    /// written, but nothing searchable changed

    Held,

    /// an edit was redacted out from under its original, which has to be read again

    Refetch(String),

    Nothing,

}

/// redactions seen lately, so a stale copy of what they removed can't come back

#[derive(Default)]

pub(crate) struct Redactions {

    order: VecDeque<String>,

    seen: HashSet<String>,

}

impl Redactions {

    fn insert(&mut self, key: String) {

        if self.seen.insert(key.clone()) {

            self.order.push_back(key);

            if self.order.len() > REMEMBERED_REDACTIONS

                && let Some(oldest) = self.order.pop_front()

            {

                self.seen.remove(&oldest);

            }

        }

    }

    fn contains(&self, key: &str) -> bool {

        self.seen.contains(key)

    }

}

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

    let text = match event_type {

        "m.room.message" => {

            let msgtype = content.get("msgtype")?.as_str()?;

            if msgtype == "m.key.verification.request" {

                return None;

            }

            let mut body = content.get("body")?.as_str()?.to_owned();

            if content.pointer("/m.relates_to/m.in_reply_to").is_some() {

                body = remove_plain_reply_fallback(&body).to_owned();

            }

            match content.get("filename").and_then(Value::as_str) {

                Some(filename) if filename != body => format!("{body}\n{filename}"),

                _ => body,

            }

        }

        "m.sticker" => content.get("body")?.as_str()?.to_owned(),

        "m.poll.start" | "org.matrix.msc3381.poll.start" => poll_question(content, event_type)?,

        _ => return None,

    };

    (!text.trim().is_empty()).then_some(text)

}

fn edit_of(value: &Value, event_type: &str) -> Option<Edit> {

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

    if content.pointer("/m.relates_to/rel_type")?.as_str()? != "m.replace" {

        return None;

    }

    Some(Edit {

        id: value.get("event_id")?.as_str()?.to_owned(),

        target: content

            .pointer("/m.relates_to/event_id")?

            .as_str()?

            .to_owned(),

        sender: value.get("sender")?.as_str()?.to_owned(),

        ts: value.get("origin_server_ts")?.as_u64()?,

        text: text_of(event_type, content.get("m.new_content")?).unwrap_or_default(),

    })

}

pub(crate) fn observe(value: &Value) -> Observed {

    observe_inner(value).unwrap_or(Observed::Other)

}

fn observe_inner(value: &Value) -> Option<Observed> {

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

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

    if event_type == "m.room.redaction" {

        let target = value

            .get("redacts")

            .or_else(|| value.pointer("/content/redacts"))?

            .as_str()?

            .to_owned();

        return Some(Observed::Redaction { target });

    }

    if value.pointer("/unsigned/redacted_because").is_some() {

        return Some(Observed::Redacted { key });

    }

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

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

        let session_id = value.pointer("/content/session_id")?.as_str()?.to_owned();

        return Some(Observed::Encrypted {

            key,

            session_id,

            ts,

        });

    }

    if value

        .pointer("/content/m.relates_to/rel_type")

        .and_then(Value::as_str)

        == Some("m.replace")

    {

        return edit_of(value, event_type).map(Observed::Edit);

    }

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

    let text = text_of(event_type, content)?;

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

    let bundled = value

        .pointer("/unsigned/m.relations/m.replace")

        .and_then(|edit| edit_of(edit, event_type))

        .filter(|edit| edit.target == key);

    Some(Observed::Message {

        key,

        sender,

        ts,

        text,

        bundled,

    })

}

fn newer(ts: u64, id: &str, than: &Doc) -> bool {

    (ts, id) > (than.content_ts, than.content.as_str())

}

/// what `observed` does to `room`'s part of the index. edits land on their original under

/// its key, the latest by its own sender wins, and one that arrives first waits under

/// `provisional_key` until the original turns up

pub(crate) fn apply(

    index: &mut dyn MessageIndex,

    redactions: &mut Redactions,

    room: &str,

    observed: Observed,

) -> Effect {

    match observed {

        Observed::Message {

            key,

            sender,

            ts,

            text,

            bundled,

        } => {

            if redactions.contains(&key) {

                return Effect::Nothing;

            }

            let mut doc = Doc {

                key: key.clone(),

                room: room.to_owned(),

                sender: sender.clone(),

                ts,

                content: key.clone(),

                content_ts: ts,

                text,

                provisional: false,

            };

            if let Some(edit) =

                bundled.filter(|edit| edit.sender == sender && !redactions.contains(&edit.id))

            {

                doc.content = edit.id;

                doc.content_ts = edit.ts;

                doc.text = edit.text;

            }

            if let Some(waiting) = index.get(&provisional_key(&key, &sender))

                && newer(waiting.content_ts, &waiting.content, &doc)

            {

                doc.content = waiting.content;

                doc.content_ts = waiting.content_ts;

                doc.text = waiting.text;

            }

            let held = index.remove_provisional(&key);

            if let Some(existing) = index.get(&key)

                && !newer(doc.content_ts, &doc.content, &existing)

            {

                return if held { Effect::Held } else { Effect::Nothing };

            }

            index.put(doc);

            Effect::Indexed(ts)

        }

        Observed::Edit(edit) => {

            if redactions.contains(&edit.target) || redactions.contains(&edit.id) {

                return Effect::Nothing;

            }

            if index

                .by_content(&edit.target)

                .is_some_and(|doc| doc.key != edit.target)

            {

                return Effect::Nothing;

            }

            if let Some(existing) = index.get(&edit.target) {

                if existing.sender != edit.sender || !newer(edit.ts, &edit.id, &existing) {

                    return Effect::Nothing;

                }

                let ts = existing.ts;

                index.put(Doc {

                    content: edit.id,

                    content_ts: edit.ts,

                    text: edit.text,

                    ..existing

                });

                return Effect::Indexed(ts);

            }

            let key = provisional_key(&edit.target, &edit.sender);

            if let Some(waiting) = index.get(&key)

                && !newer(edit.ts, &edit.id, &waiting)

            {

                return Effect::Nothing;

            }

            index.put(Doc {

                key,

                room: room.to_owned(),

                sender: edit.sender,

                ts: edit.ts,

                content: edit.id,

                content_ts: edit.ts,

                text: edit.text,

                provisional: true,

            });

            Effect::Held

        }

        Observed::Redaction { target } | Observed::Redacted { key: target } => {

            redactions.insert(target.clone());

            let removed = index.remove(&target);

            if index.remove_provisional(&target) || removed {

                return Effect::Removed;

            }

            match index.by_content(&target) {

                Some(doc) if doc.key != target => {

                    index.remove(&doc.key);

                    if doc.provisional {

                        Effect::Removed

                    } else {

                        Effect::Refetch(doc.key)

                    }

                }

                _ => Effect::Nothing,

            }

        }

        Observed::Encrypted { .. } | Observed::Other => Effect::Nothing,

    }

}

#[cfg(test)]

#[path = "feed_tests.rs"]

mod tests;