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

use crate::padfoot::VarArg;
use crate::telepathy;

use dbus::tree::MethodErr;
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
    }

    fn pending_messages(&self) -> Result<Vec<Vec<HashMap<String, VarArg>>>> {
        let out = Vec::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::msg::Message::load_from_db(&ctx, msg_id) {
                        let lot = msg.get_summary(&ctx, None);

                        if lot
                    }
                }

                println!("Channel::pending_messages()");
        */
        Ok(out) // FIXME: check for pending messages
    }

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

        Ok(0) // FIXME: MDNs
    }
}