telepathy-padfoot/src/padfoot/channel/messages.rs

use crate::padfoot::{var_i64, var_str, var_u32, VarArg};
use crate::telepathy;

use dbus::tree::MethodErr;
use dc::message::MessageState;
use deltachat as dc;
use std::collections::HashMap;

use super::{Channel, Result};

impl AsRef<dyn telepathy::ChannelInterfaceMessages + 'static> for std::sync::Arc<Channel> {
    fn as_ref(&self) -> &(dyn telepathy::ChannelInterfaceMessages + 'static) {
        &**self
    }
}

impl telepathy::ChannelInterfaceMessages for Channel {
    fn send_message(&self, message: Vec<HashMap<&str, VarArg>>, flags: u32) -> Result<String> {
        println!("Channel::send_message({:?}, {})", message, flags);
        Err(MethodErr::no_arg())
    }

    fn get_pending_message_content(
        &self,
        message_id: u32,
        parts: Vec<u32>,
    ) -> Result<HashMap<u32, VarArg>> {
        println!(
            "Channel::get_pending_message_content({}, {:?})",
            message_id, parts
        );
        Err(MethodErr::no_arg())
    }

    fn supported_content_types(&self) -> Result<Vec<String>> {
        println!("Channel::supported_content_types()");

        Ok(vec!["text/plain".to_string()]) // TODO: image support
    }

    fn message_types(&self) -> Result<Vec<u32>> {
        println!("Channel::message_types()");

        Ok(vec![0]) // Normal messages. FIXME: MDNs too
    }

    fn message_part_support_flags(&self) -> Result<u32> {
        println!("Channel::message_part_support_flags()");

        Ok(0) // FIXME: support multipart messages
    }

    // Return value is an array of array of message parts
    fn pending_messages(&self) -> Result<Vec<Vec<HashMap<String, VarArg>>>> {
        println!("Channel::pending_messages()");

        let mut out = Vec::<Vec<HashMap<String, VarArg>>>::new();
        let ctx = self.ctx.read().unwrap();

        for msg_id in dc::chat::get_chat_msgs(&ctx, self.chat_id, 0, None) {
            if let Ok(msg) = dc::message::Message::load_from_db(&ctx, msg_id) {
                println!("    A message: {:?}", msg);
                match msg.get_state() {
                    MessageState::InFresh | MessageState::InNoticed => {
                        let mut parts = Vec::new();
                        let mut props = HashMap::new();
                        props.insert(
                            "message-token".to_string(),
                            var_str(format!("{}", msg_id.to_u32())),
                        );
                        props.insert("message-sent".to_string(), var_i64(msg.get_timestamp()));
                        props.insert(
                            "message-received".to_string(),
                            var_i64(msg.get_received_timestamp()),
                        );
                        props.insert("message-sender".to_string(), var_u32(msg.get_from_id()));
                        // props.insert("message-sender-id", var_str()); // This doesn't need to be sent
                        // props.insert("sender-nickname", var_str()); // Can we get away without this one?
                        props.insert("message-type".to_string(), var_u32(0)); // normal

                        // These relate to superseded messages
                        // props.insert("supersedes", var_str());
                        // props.insert("original-message-sent", var_i64());
                        // props.insert("original-message-received", var_i64());

                        props.insert("pending-message-id".to_string(), var_u32(msg_id.to_u32()));

                        parts.push(props);

                        // Don't need these
                        // props.insert("interface", var_str());
                        // props.insert("scrollback", var_vool());
                        // props.insert("silent", var_bool());
                        // props.insert("rescued", var_bool());

                        if let Some(text) = msg.get_text() {
                            let mut part = HashMap::new();
                            part.insert(
                                "content-type".to_string(),
                                var_str("text/plain".to_string()),
                            );
                            part.insert("content".to_string(), var_str(text));
                            parts.push(part);
                        }

                        out.push(parts);
                    }
                    _ => continue,
                }
            }
        }

        Ok(out) // FIXME: check for pending messages
    }

    fn delivery_reporting_support(&self) -> Result<u32> {
        println!("Channel::delivery_reporting_support()");

        Ok(0) // FIXME: MDNs
    }
}