Check rerouted history for message references when fetching chathistory.

Author: andymandias

data/src/history.rs

@@ -663,7 +663,7 @@ impl History {
                 let max_triggers_highlight =
                     metadata::latest_triggers_highlight(messages);
                 let chathistory_references =
-                    metadata::latest_can_reference(messages);
+                    metadata::latest_can_reference(messages, None);
 
                 let full_history = std::mem::replace(
                     self,
@@ -760,14 +760,15 @@ impl History {
         match self {
             History::Partial { messages, .. }
             | History::Full { messages, .. } => {
-                messages.iter().find(|message| message.can_reference())
+                messages.iter().find(|message| message.can_reference(None))
             }
         }
     }
 
     pub fn last_can_reference_before(
         &self,
         server_time: DateTime<Utc>,
+        rerouted_from: Option<&Target>,
     ) -> Option<MessageReferences> {
         match self {
             History::Partial {
@@ -778,7 +779,8 @@ impl History {
                 .iter()
                 .rev()
                 .find(|message| {
-                    message.can_reference() && message.server_time < server_time
+                    message.can_reference(rerouted_from)
+                        && message.server_time < server_time
                 })
                 .map_or(
                     if chathistory_references.as_ref().is_some_and(
@@ -796,7 +798,8 @@ impl History {
                 .iter()
                 .rev()
                 .find(|message| {
-                    message.can_reference() && message.server_time < server_time
+                    message.can_reference(rerouted_from)
+                        && message.server_time < server_time
                 })
                 .map(Message::references),
         }

data/src/history/manager.rs

@@ -519,8 +519,19 @@ impl Manager {
         target: Target,
         server_time: DateTime<Utc>,
     ) -> Option<MessageReferences> {
-        self.data
-            .last_can_reference_before(server, target, server_time)
+        let reroute_target = match &target {
+            Target::Channel(_) => None,
+            Target::Query(query) => {
+                self.reroute_rules.history_kind_for_query(query, &server)
+            }
+        };
+
+        self.data.last_can_reference_before(
+            server,
+            target,
+            server_time,
+            reroute_target,
+        )
     }
 
     pub fn mark_as_read(&mut self, kind: &history::Kind) -> Option<ReadMarker> {
@@ -1636,12 +1647,22 @@ impl Data {
         server: Server,
         target: Target,
         server_time: DateTime<Utc>,
+        reroute_target: Option<history::Kind>,
     ) -> Option<MessageReferences> {
+        let reroute_reference = reroute_target
+            .and_then(|kind| self.map.get(&kind))
+            .and_then(|history| {
+                history.last_can_reference_before(server_time, Some(&target))
+            });
+
         let kind = history::Kind::from_target(server, target);
 
         self.map
             .get(&kind)
-            .and_then(|history| history.last_can_reference_before(server_time))
+            .and_then(|history| {
+                history.last_can_reference_before(server_time, None)
+            })
+            .max(reroute_reference)
     }
 
     fn mark_as_read(&mut self, kind: &history::Kind) -> Option<ReadMarker> {

data/src/history/metadata.rs

@@ -10,6 +10,7 @@ use tokio::fs;
 use crate::Message;
 use crate::history::{Error, Kind, dir_path};
 use crate::message::{MessageReferences, source};
+use crate::target::Target;
 
 #[derive(Debug, Clone, Default, Deserialize, Serialize)]
 pub struct Metadata {
@@ -97,11 +98,14 @@ pub fn latest_triggers_highlight(
         .map(|message| message.server_time)
 }
 
-pub fn latest_can_reference(messages: &[Message]) -> Option<MessageReferences> {
+pub fn latest_can_reference(
+    messages: &[Message],
+    rerouted_from: Option<&Target>,
+) -> Option<MessageReferences> {
     messages
         .iter()
         .rev()
-        .find(|message| message.can_reference())
+        .find(|message| message.can_reference(rerouted_from))
         .map(Message::references)
 }
 
@@ -124,7 +128,7 @@ pub async fn save(
         read_marker,
         last_triggers_unread: latest_triggers_unread(messages),
         last_triggers_highlight: latest_triggers_highlight(messages),
-        chathistory_references: latest_can_reference(messages),
+        chathistory_references: latest_can_reference(messages, None),
     })?;
 
     let path = path(kind).await?;

data/src/history/reroute.rs

@@ -2,7 +2,9 @@ use std::collections::HashMap;
 use std::sync::Arc;
 
 use crate::user::Nick;
-use crate::{Server, client, config, isupport, message, server, target};
+use crate::{
+    Server, client, config, history, isupport, message, server, target,
+};
 
 #[derive(Debug, Clone, PartialEq, Eq, Default)]
 pub struct RerouteRules {
@@ -128,7 +130,7 @@ impl RerouteRules {
             })
     }
 
-    pub fn target_for_query(
+    pub fn message_target_for_query(
         &self,
         query: &target::Query,
         server: &Server,
@@ -154,6 +156,27 @@ impl RerouteRules {
             })
         })
     }
+
+    pub fn history_kind_for_query(
+        &self,
+        query: &target::Query,
+        server: &Server,
+    ) -> Option<history::Kind> {
+        self.direct_messages.get(server).and_then(|reroute_rules| {
+            reroute_rules.iter().find_map(|reroute_rule| {
+                (query.as_normalized_str()
+                    == reroute_rule.from.as_normalized_str())
+                .then_some(match &reroute_rule.to {
+                    DirectMessageRerouteTarget::Channel(channel) => {
+                        history::Kind::Channel(server.clone(), channel.clone())
+                    }
+                    DirectMessageRerouteTarget::Server => {
+                        history::Kind::Server(server.clone())
+                    }
+                })
+            })
+        })
+    }
 }
 
 fn matches_server_label(rule_server: &str, server: &Server) -> bool {

data/src/message.rs

@@ -109,7 +109,7 @@ pub fn reroute_private_target(
 ) -> Option<Target> {
     match target {
         Target::Query { query, source } => {
-            reroute_rules.target_for_query(query, server, source)
+            reroute_rules.message_target_for_query(query, server, source)
         }
         _ => None,
     }
@@ -335,11 +335,39 @@ impl Message {
         }
     }
 
-    pub fn can_reference(&self) -> bool {
+    pub fn can_reference(
+        &self,
+        rerouted_from: Option<&target::Target>,
+    ) -> bool {
         if matches!(self.direction, Direction::Sent)
             || self.is_echo
             || matches!(self.target.source(), Source::Internal(_))
-            || is_rerouted_private_message(self)
+            || self.rerouted_from.as_ref().zip(rerouted_from).is_some_and(
+                |(message_target, target)| match target {
+                    target::Target::Channel(channel) => {
+                        if let message::Target::Channel {
+                            channel: message_channel,
+                            ..
+                        } = &message_target
+                        {
+                            *channel == *message_channel
+                        } else {
+                            false
+                        }
+                    }
+                    target::Target::Query(query) => {
+                        if let message::Target::Query {
+                            query: message_query,
+                            ..
+                        } = &message_target
+                        {
+                            *query == *message_query
+                        } else {
+                            false
+                        }
+                    }
+                },
+            )
         {
             return false;
         } else if let Source::Server(Some(source)) = self.target.source()