// Take a look at the license at the top of the repository in the LICENSE file.

use crate::TestClock;
use glib::translate::*;
use std::ptr;

impl TestClock {
    /// Checks whether `self` was requested to provide the clock notification
    /// given by `id`.
    ///
    /// MT safe.
    /// ## `id`
    /// a `GstClockID` clock notification
    ///
    /// # Returns
    ///
    /// [`true`] if the clock has been asked to provide the given clock
    /// notification, [`false`] otherwise.
    #[doc(alias = "gst_test_clock_has_id")]
    pub fn has_id(&self, id: &gst::ClockId) -> bool {
        unsafe {
            from_glib(ffi::gst_test_clock_has_id(
                self.to_glib_none().0,
                id.to_glib_none().0,
            ))
        }
    }

    /// Determines if the `pending_id` is the next clock notification scheduled to
    /// be triggered given the current time of the `self`.
    ///
    /// MT safe.
    ///
    /// # Returns
    ///
    /// [`true`] if `pending_id` is the next clock notification to be
    /// triggered, [`false`] otherwise.
    ///
    /// ## `pending_id`
    /// a `GstClockID` clock
    /// notification to look for
    #[doc(alias = "gst_test_clock_peek_next_pending_id")]
    pub fn peek_next_pending_id(&self) -> Option<gst::ClockId> {
        unsafe {
            let mut id = ptr::null_mut();
            let ret: bool = from_glib(ffi::gst_test_clock_peek_next_pending_id(
                self.to_glib_none().0,
                &mut id,
            ));
            if ret {
                from_glib_full(id)
            } else {
                None
            }
        }
    }

    /// Processes and releases the pending ID.
    ///
    /// MT safe.
    /// ## `pending_id`
    /// `GstClockID`
    #[cfg(any(feature = "v1_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
    #[doc(alias = "gst_test_clock_process_id")]
    pub fn process_id(&self, pending_id: &gst::ClockId) -> bool {
        unsafe {
            from_glib(ffi::gst_test_clock_process_id(
                self.to_glib_none().0,
                pending_id.to_glib_none().0,
            ))
        }
    }

    /// Processes and releases the pending IDs in the list.
    ///
    /// MT safe.
    /// ## `pending_list`
    /// List
    ///  of pending `GstClockIDs`
    #[doc(alias = "gst_test_clock_process_id_list")]
    pub fn process_id_list(&self, pending_list: &[&gst::ClockId]) -> u32 {
        unsafe {
            ffi::gst_test_clock_process_id_list(
                self.to_glib_none().0,
                pending_list.to_glib_none().0,
            )
        }
    }

    /// MT safe.
    ///
    /// # Returns
    ///
    /// a `GstClockID` containing the next pending clock
    /// notification.
    #[doc(alias = "gst_test_clock_process_next_clock_id")]
    pub fn process_next_clock_id(&self) -> Option<gst::ClockId> {
        unsafe {
            from_glib_full(ffi::gst_test_clock_process_next_clock_id(
                self.to_glib_none().0,
            ))
        }
    }

    /// Blocks until at least `count` clock notifications have been requested from
    /// `self`. There is no timeout for this wait, see the main description of
    /// [`TestClock`][crate::TestClock].
    ///
    /// MT safe.
    /// ## `count`
    /// the number of pending clock notifications to wait for
    ///
    /// # Returns
    ///
    ///
    /// ## `pending_list`
    /// Address
    ///  of a `GList` pointer variable to store the list of pending `GstClockIDs`
    ///  that expired, or [`None`]
    #[doc(alias = "gst_test_clock_wait_for_multiple_pending_ids")]
    pub fn wait_for_multiple_pending_ids(&self, count: u32) -> Vec<gst::ClockId> {
        unsafe {
            let mut pending_list = ptr::null_mut();
            ffi::gst_test_clock_wait_for_multiple_pending_ids(
                self.to_glib_none().0,
                count,
                &mut pending_list,
            );
            FromGlibPtrContainer::from_glib_full(pending_list)
        }
    }

    /// Waits until a clock notification is requested from `self`. There is no
    /// timeout for this wait, see the main description of [`TestClock`][crate::TestClock]. A reference
    /// to the pending clock notification is stored in `pending_id`.
    ///
    /// MT safe.
    ///
    /// # Returns
    ///
    ///
    /// ## `pending_id`
    /// `GstClockID`
    /// with information about the pending clock notification
    #[doc(alias = "gst_test_clock_wait_for_next_pending_id")]
    pub fn wait_for_next_pending_id(&self) -> gst::ClockId {
        unsafe {
            let mut id = ptr::null_mut();
            ffi::gst_test_clock_wait_for_next_pending_id(self.to_glib_none().0, &mut id);
            from_glib_full(id)
        }
    }

    /// Blocks until at least `count` clock notifications have been requested from
    /// `self`, or the timeout expires.
    ///
    /// MT safe.
    /// ## `count`
    /// the number of pending clock notifications to wait for
    /// ## `timeout_ms`
    /// the timeout in milliseconds
    ///
    /// # Returns
    ///
    /// a `gboolean` [`true`] if the waits have been registered, [`false`] if not.
    /// (Could be that it timed out waiting or that more waits than waits was found)
    ///
    /// ## `pending_list`
    /// Address
    ///  of a `GList` pointer variable to store the list of pending `GstClockIDs`
    ///  that expired, or [`None`]
    #[cfg(any(feature = "v1_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
    #[doc(alias = "gst_test_clock_timed_wait_for_multiple_pending_ids")]
    pub fn timed_wait_for_multiple_pending_ids(
        &self,
        count: u32,
        timeout_ms: u32,
    ) -> (bool, Vec<gst::ClockId>) {
        unsafe {
            let mut pending_list = ptr::null_mut();
            let res = ffi::gst_test_clock_timed_wait_for_multiple_pending_ids(
                self.to_glib_none().0,
                count,
                timeout_ms,
                &mut pending_list,
            );
            (
                from_glib(res),
                FromGlibPtrContainer::from_glib_full(pending_list),
            )
        }
    }
}