malice

use serde_json::{Value, json};

const TITLE_CHARS: usize = 80;

const BODY_CHARS: usize = 400;

/// What a push says about its event, before it becomes notification text.

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

pub enum Content {

    Text(String),

    Emote(String),

    /// e.g. "sent an image", shown after the sender's name

    Action(&'static str),

    Encrypted,

}

impl Content {

    pub fn of(event_type: Option<&str>, content: Option<&Value>, user_is_target: bool) -> Self {

        let field = |name: &str| content.and_then(|content| content.get(name)?.as_str());

        match event_type.unwrap_or_default() {

            "m.room.encrypted" => Self::Encrypted,

            "m.room.message" => match (field("msgtype"), field("body")) {

                (Some("m.text" | "m.notice"), Some(body)) => Self::Text(strip_reply_fallback(body)),

                (Some("m.emote"), Some(body)) => Self::Emote(strip_reply_fallback(body)),

                (Some("m.image"), _) => Self::Action("sent an image"),

                (Some("m.video"), _) => Self::Action("sent a video"),

                (Some("m.audio"), _) => Self::Action("sent an audio clip"),

                (Some("m.file"), _) => Self::Action("sent a file"),

                (Some("m.location"), _) => Self::Action("shared a location"),

                (_, Some(body)) => Self::Text(strip_reply_fallback(body)),

                (_, None) => Self::Action("sent a message"),

            },

            "m.sticker" => Self::Action("sent a sticker"),

            "m.room.member" if user_is_target && field("membership") == Some("invite") => {

                Self::Action("invited you")

            }

            "m.call.invite" => Self::Action("is calling"),

            "m.poll.start" | "org.matrix.msc3381.poll.start" => Self::Action("started a poll"),

            _ => Self::Action("sent a message"),

        }

    }

    pub fn body(&self, sender: &str, direct: bool) -> String {

        match (self, direct) {

            (Self::Text(text), true) => text.clone(),

            (Self::Text(text), false) => format!("{sender}: {text}"),

            (Self::Emote(text), _) => format!("* {sender} {text}"),

            (Self::Action(action), _) => format!("{sender} {action}"),

            (Self::Encrypted, true) => "Encrypted message".to_owned(),

            (Self::Encrypted, false) => format!("{sender}: Encrypted message"),

        }

    }

}

/// Older clients quote the replied-to message as leading "> " lines and a

/// blank line, which would crowd out the reply itself.

fn strip_reply_fallback(body: &str) -> String {

    if !body.starts_with("> ") {

        return body.to_owned();

    }

    let mut lines = body.lines().skip_while(|line| line.starts_with('>'));

    let rest: Vec<&str> = match lines.next() {

        Some("") | None => lines.collect(),

        Some(first) => std::iter::once(first).chain(lines).collect(),

    };

    if rest.is_empty() {

        body.to_owned()

    } else {

        rest.join("\n")

    }

}

/// The notification one push shows, in the Declarative Web Push shape so

/// Safari can display it without running the service worker.

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

pub struct Notice {

    pub title: String,

    pub body: String,

    pub room_id: String,

    pub event_id: String,

    /// the body is generic because the event could not be read

    pub encrypted: bool,

    pub mention: bool,

    pub silent: bool,

    pub unread: Option<u64>,

}

impl Notice {

    /// `origin` without a trailing slash, or empty for a relative `navigate`.

    pub fn to_value(&self, origin: &str) -> Value {

        let room = &self.room_id;

        let mut notification = json!({

            "title": truncate(&self.title, TITLE_CHARS),

            "body": truncate(&self.body, BODY_CHARS),

            "navigate": format!("{origin}/?room={}", query_escape(room)),

            "tag": format!("room:{room}"),

            "silent": self.silent,

        });

        if let Some(unread) = self.unread {

            notification["app_badge"] = Value::String(unread.to_string());

        }

        json!({

            "web_push": 8030,

            "notification": notification,

            "malice": {

                "room_id": room,

                "event_id": self.event_id,

                "encrypted": self.encrypted,

                "mention": self.mention,

                "unread": self.unread,

            },

        })

    }

    pub fn to_bytes(&self, origin: &str) -> Vec<u8> {

        serde_json::to_vec(&self.to_value(origin)).expect("a json value serialises")

    }

}

fn truncate(text: &str, max: usize) -> String {

    match text.char_indices().nth(max) {

        Some((end, _)) => format!("{}…", text[..end].trim_end()),

        None => text.to_owned(),

    }

}

fn query_escape(value: &str) -> String {

    let mut out = String::with_capacity(value.len());

    for byte in value.bytes() {

        match byte {

            b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'.' | b'_' | b'~' | b'!' | b':' => {

                out.push(byte as char);

            }

            _ => out.push_str(&format!("%{byte:02X}")),

        }

    }

    out

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn content_reads_messages_and_hides_encrypted_ones() {

        let text = json!({"msgtype": "m.text", "body": "> <@a:x> old\n\nnew"});

        assert_eq!(

            Content::of(Some("m.room.message"), Some(&text), false),

            Content::Text("new".to_owned())

        );

        assert_eq!(

            Content::of(

                Some("m.room.encrypted"),

                Some(&json!({"ciphertext": "x"})),

                false

            ),

            Content::Encrypted

        );

        let image = json!({"msgtype": "m.image", "body": "cat.png"});

        assert_eq!(

            Content::of(Some("m.room.message"), Some(&image), false).body("Ann", false),

            "Ann sent an image"

        );

        assert_eq!(Content::Text("hi".to_owned()).body("Ann", false), "Ann: hi");

        assert_eq!(Content::Text("hi".to_owned()).body("Ann", true), "hi");

        let invite = json!({"membership": "invite"});

        assert_eq!(

            Content::of(Some("m.room.member"), Some(&invite), true),

            Content::Action("invited you")

        );

    }

    #[test]

    fn notice_matches_the_wire_contract_and_stays_small() {

        let notice = Notice {

            title: "Room".to_owned(),

            body: "x".repeat(5000),

            room_id: "!r:example.org".to_owned(),

            event_id: "$e".to_owned(),

            encrypted: false,

            mention: true,

            silent: false,

            unread: Some(3),

        };

        let value = notice.to_value("https://chat.example");

        assert_eq!(value["web_push"], 8030);

        assert_eq!(

            value["notification"]["navigate"],

            "https://chat.example/?room=!r:example.org"

        );

        assert_eq!(value["notification"]["tag"], "room:!r:example.org");

        assert_eq!(value["notification"]["app_badge"], "3");

        assert_eq!(value["malice"]["unread"], 3);

        assert_eq!(value["malice"]["mention"], true);

        assert!(notice.to_bytes("https://chat.example").len() < 3 * 1024);

        let unknown = Notice {

            unread: None,

            ..notice

        }

        .to_value("");

        assert!(unknown["notification"].get("app_badge").is_none());

        assert_eq!(unknown["malice"]["unread"], Value::Null);

    }

}