//! A connection that uses FFI callbacks to dispatch messages.

//!

//! This is the legacy design used up to 0.6.x. It is not recommended for new development.

use super::{Error, ffi, Message, MessageType};

use crate::strings::{BusName, Path, Member, Interface};

use crate::arg::{AppendAll, ReadAll, IterAppend};

use crate::message::SignalArgs;

pub mod stdintf;

mod connection;

pub use connection::{Connection, ConnMsgs};

/// A convenience struct that wraps connection, destination and path.

///

/// Useful if you want to make many method calls to the same destination path.

#[derive(Clone, Debug)]

pub struct ConnPath<'a, C> {

    /// Some way to access the connection, e g a &Connection or Rc<Connection>

    pub conn: C,

    /// Destination, i e what D-Bus service you're communicating with

    pub dest: BusName<'a>,

    /// Object path on the destination

    pub path: Path<'a>,

    /// Timeout in milliseconds for blocking method calls

    pub timeout: i32,

}

impl<'a, C: ::std::ops::Deref<Target=Connection>> ConnPath<'a, C> {

    /// Make a D-Bus method call, where you can append arguments inside the closure.

    pub fn method_call_with_args<F: FnOnce(&mut Message)>(&self, i: &Interface, m: &Member, f: F) -> Result<Message, Error> {

        let mut msg = Message::method_call(&self.dest, &self.path, i, m);

        f(&mut msg);

        self.conn.send_with_reply_and_block(msg, self.timeout)

    }

    /// Emit a D-Bus signal, where you can append arguments inside the closure.

    pub fn signal_with_args<F: FnOnce(&mut Message)>(&self, i: &Interface, m: &Member, f: F) -> Result<u32, Error> {

        let mut msg = Message::signal(&self.path, i, m);

        f(&mut msg);

        self.conn.send(msg).map_err(|_| Error::new_failed("Sending signal failed"))

    }

    /// Emit a D-Bus signal, where the arguments are in a struct.

    pub fn emit<S: SignalArgs + AppendAll>(&self, signal: &S) -> Result<u32, Error> {

        let msg = signal.to_emit_message(&self.path);

        self.conn.send(msg).map_err(|_| Error::new_failed("Sending signal failed"))

    }

    /// Make a method call using typed input and output arguments.

    ///

    /// # Example

    ///

    /// ```

    /// use dbus::ffidisp::{Connection, BusType};

    ///

    /// let conn = Connection::get_private(BusType::Session)?;

    /// let dest = conn.with_path("org.freedesktop.DBus", "/", 5000);

    /// let (has_owner,): (bool,) = dest.method_call("org.freedesktop.DBus", "NameHasOwner", ("dummy.name.without.owner",))?;

    /// assert_eq!(has_owner, false);

    /// # Ok::<(), Box<dyn std::error::Error>>(())

    /// ```

    pub fn method_call<'i, 'm, R: ReadAll, A: AppendAll, I: Into<Interface<'i>>, M: Into<Member<'m>>>(&self, i: I, m: M, args: A) -> Result<R, Error> {

        let mut r = self.method_call_with_args(&i.into(), &m.into(), |mut msg| {

            args.append(&mut IterAppend::new(&mut msg));

        })?;

        r.as_result()?;

        Ok(R::read(&mut r.iter_init())?)

    }

}

/// The type of function to use for replacing the message callback.

///

/// See the documentation for Connection::replace_message_callback for more information.

pub type MessageCallback = Box<dyn FnMut(&Connection, Message) -> bool + 'static>;

pub use crate::ffi::DBusRequestNameReply as RequestNameReply;

pub use crate::ffi::DBusReleaseNameReply as ReleaseNameReply;

pub use crate::ffi::DBusBusType as BusType;

mod watch;

pub use self::watch::{Watch, WatchEvent};

use watch::WatchList;

#[repr(C)]

#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Copy, Clone)]

/// Flags to use for Connection::register_name.

///

/// More than one flag can be specified, if so just add their values.

pub enum NameFlag {

    /// Allow another service to become the primary owner if requested

    AllowReplacement = ffi::DBUS_NAME_FLAG_ALLOW_REPLACEMENT as isize,

    /// Request to replace the current primary owner

    ReplaceExisting = ffi::DBUS_NAME_FLAG_REPLACE_EXISTING as isize,

    /// If we can not become the primary owner do not place us in the queue

    DoNotQueue = ffi::DBUS_NAME_FLAG_DO_NOT_QUEUE as isize,

}

impl NameFlag {

    /// u32 value of flag.

    pub fn value(self) -> u32 { self as u32 }

}

/// When listening for incoming events on the D-Bus, this enum will tell you what type

/// of incoming event has happened.

#[derive(Debug)]

pub enum ConnectionItem {

    /// No event between now and timeout

    Nothing,

    /// Incoming method call

    MethodCall(Message),

    /// Incoming signal

    Signal(Message),

    /// Incoming method return, including method return errors (mostly used for Async I/O)

    MethodReturn(Message),

}

impl From<Message> for ConnectionItem {

    fn from(m: Message) -> Self {

        let mtype = m.msg_type();

        match mtype {

            MessageType::Signal => ConnectionItem::Signal(m),

            MessageType::MethodReturn => ConnectionItem::MethodReturn(m),

            MessageType::Error => ConnectionItem::MethodReturn(m),

            MessageType::MethodCall => ConnectionItem::MethodCall(m),

        }

    }

}

#[derive(Clone, Debug)]

/// Type of messages to be handled by a MsgHandler.

///

/// Note: More variants can be added in the future; but unless you're writing your own D-Bus engine

/// you should not have to match on these anyway.

pub enum MsgHandlerType {

    /// Handle all messages

    All,

    /// Handle only messages of a specific type

    MsgType(MessageType),

    /// Handle only method replies with this serial number

    Reply(u32),

}

impl MsgHandlerType {

    fn matches_msg(&self, m: &Message) -> bool {

        match *self {

            MsgHandlerType::All => true,

            MsgHandlerType::MsgType(t) => m.msg_type() == t,

            MsgHandlerType::Reply(serial) => {

                let t = m.msg_type();

                ((t == MessageType::MethodReturn) || (t == MessageType::Error)) && (m.get_reply_serial() == Some(serial))

            }

        }

    }

}

/// A trait for handling incoming messages.

pub trait MsgHandler {

    /// Type of messages for which the handler will be called

    ///

    /// Note: The return value of this function might be cached, so it must return the same value all the time.

    fn handler_type(&self) -> MsgHandlerType;

    /// Function to be called if the message matches the MsgHandlerType

    fn handle_msg(&mut self, _msg: &Message) -> Option<MsgHandlerResult> { None }

}

/// The result from MsgHandler::handle.

#[derive(Debug, Default)]

pub struct MsgHandlerResult {

    /// Indicates that the message has been dealt with and should not be processed further.

    pub handled: bool,

    /// Indicates that this MsgHandler no longer wants to receive messages and should be removed.

    pub done: bool,

    /// Messages to send (e g, a reply to a method call)

    pub reply: Vec<Message>,

}

type MsgHandlerList = Vec<Box<dyn MsgHandler>>;

/// The struct returned from `Connection::send_and_reply`.

///

/// It implements the `MsgHandler` trait so you can use `Connection::add_handler`.

pub struct MessageReply<F>(Option<F>, u32);

impl<'a, F: FnOnce(Result<&Message, Error>) + 'a> MsgHandler for MessageReply<F> {

    fn handler_type(&self) -> MsgHandlerType { MsgHandlerType::Reply(self.1) }

    fn handle_msg(&mut self, msg: &Message) -> Option<MsgHandlerResult> {

        let e = match msg.msg_type() {

            MessageType::MethodReturn => Ok(msg),

            MessageType::Error => Err(msg.set_error_from_msg().unwrap_err()),

            _ => unreachable!(),

        };

        debug_assert_eq!(msg.get_reply_serial(), Some(self.1));

        self.0.take().unwrap()(e);

        return Some(MsgHandlerResult { handled: true, done: true, reply: Vec::new() })

    }

}

#[cfg(test)]

mod test {

    use super::{Connection, BusType, ConnectionItem, NameFlag,

        RequestNameReply, ReleaseNameReply};

    use crate::Message;

    #[test]

    fn connection() {

        let c = Connection::get_private(BusType::Session).unwrap();

        let n = c.unique_name();

        assert!(n.starts_with(":1."));

        println!("Connected to DBus, unique name: {}", n);

    }

    #[test]

    fn invalid_message() {

        let c = Connection::get_private(BusType::Session).unwrap();

        let m = Message::new_method_call("foo.bar", "/", "foo.bar", "FooBar").unwrap();

        let e = c.send_with_reply_and_block(m, 2000).err().unwrap();

        assert!(e.name().unwrap() == "org.freedesktop.DBus.Error.ServiceUnknown");

    }

    #[test]

    fn object_path() {

        use  std::sync::mpsc;

        let (tx, rx) = mpsc::channel();

        let thread = ::std::thread::spawn(move || {

            let c = Connection::get_private(BusType::Session).unwrap();

            c.register_object_path("/hello").unwrap();

            // println!("Waiting...");

            tx.send(c.unique_name()).unwrap();

            for n in c.iter(1000) {

                // println!("Found message... ({})", n);

                match n {

                    ConnectionItem::MethodCall(ref m) => {

                        let reply = Message::new_method_return(m).unwrap();

                        c.send(reply).unwrap();

                        break;

                    }

                    _ => {}

                }

            }

            c.unregister_object_path("/hello");

        });

        let c = Connection::get_private(BusType::Session).unwrap();

        let n = rx.recv().unwrap();

        let m = Message::new_method_call(&n, "/hello", "com.example.hello", "Hello").unwrap();

        println!("Sending...");

        let r = c.send_with_reply_and_block(m, 8000).unwrap();

        let reply = r.get_items();

        println!("{:?}", reply);

        thread.join().unwrap();

    }

    #[test]

    fn register_name() {

        let c = Connection::get_private(BusType::Session).unwrap();

        let n = format!("com.example.hello.test.register_name");

        assert_eq!(c.register_name(&n, NameFlag::ReplaceExisting as u32).unwrap(), RequestNameReply::PrimaryOwner);

        assert_eq!(c.release_name(&n).unwrap(), ReleaseNameReply::Released);

    }

    #[test]

    fn signal() {

        let c = Connection::get_private(BusType::Session).unwrap();

        let iface = "com.example.signaltest";

        let mstr = format!("interface='{}',member='ThisIsASignal'", iface);

        c.add_match(&mstr).unwrap();

        let m = Message::new_signal("/mysignal", iface, "ThisIsASignal").unwrap();

        let uname = c.unique_name();

        c.send(m).unwrap();

        for n in c.iter(1000) {

            match n {

                ConnectionItem::Signal(s) => {

                    let (p, i, m) = (s.path(), s.interface(), s.member());

                    match (&*p.unwrap(), &*i.unwrap(), &*m.unwrap()) {

                        ("/mysignal", "com.example.signaltest", "ThisIsASignal") => {

                            assert_eq!(&*s.sender().unwrap(), &*uname);

                            break;

                        },

                        (_, _, _) => println!("Other signal: {:?}", s),

                    }

                }

                _ => {},

            }

        }

        c.remove_match(&mstr).unwrap();

    }

    #[test]

    fn watch() {

        let c = Connection::get_private(BusType::Session).unwrap();

        let d = c.watch_fds();

        assert!(d.len() > 0);

        println!("Fds to watch: {:?}", d);

    }

}