1 files changed, 76 insertions, 0 deletions
diff --git a/src/message/snapshot.rs b/src/message/snapshot.rs
new file mode 100644
index 0000000..522c1aa
--- /dev/null
+++ b/src/message/snapshot.rs
@@ -0,0 +1,76 @@
+use super::{
+    event::{Event, Kind, Sent},
+    Id,
+};
+use crate::{channel::Channel, event::Instant, login::Login};
+
+#[derive(Clone, Debug, Eq, PartialEq, serde::Serialize)]
+#[serde(into = "self::serialize::Message")]
+pub struct Message {
+    #[serde(skip)]
+    pub sent: Instant,
+    pub channel: Channel,
+    pub sender: Login,
+    pub id: Id,
+    pub body: String,
+}
+
+mod serialize {
+    use crate::{channel::Channel, login::Login, message::Id};
+
+    #[derive(serde::Serialize)]
+    pub struct Message {
+        channel: Channel,
+        sender: Login,
+        #[allow(clippy::struct_field_names)]
+        // Deliberately redundant with the module path; this produces a specific serialization.
+        message: MessageData,
+    }
+
+    #[derive(serde::Serialize)]
+    pub struct MessageData {
+        id: Id,
+        body: String,
+    }
+
+    impl From<super::Message> for Message {
+        fn from(message: super::Message) -> Self {
+            Self {
+                channel: message.channel,
+                sender: message.sender,
+                message: MessageData {
+                    id: message.id,
+                    body: message.body,
+                },
+            }
+        }
+    }
+}
+
+impl Message {
+    fn apply(state: Option<Self>, event: Event) -> Option<Self> {
+        match (state, event.kind) {
+            (None, Kind::Sent(event)) => Some(event.into()),
+            (Some(message), Kind::Deleted(event)) if message.id == event.message => None,
+            (state, event) => panic!("invalid message event {event:#?} for state {state:#?}"),
+        }
+    }
+}
+
+impl FromIterator<Event> for Option<Message> {
+    fn from_iter<I: IntoIterator<Item = Event>>(events: I) -> Self {
+        events.into_iter().fold(None, Message::apply)
+    }
+}
+
+impl From<&Sent> for Message {
+    fn from(event: &Sent) -> Self {
+        event.message.clone()
+    }
+}
+
+impl From<Sent> for Message {
+    fn from(event: Sent) -> Self {
+        event.message
+    }
+}