// Copyright (C) 2018 Sebastian Dröge <sebastian@centricular.com>
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

use glib::translate::*;
use gst;
use gst_check_sys;
use std::ptr;
use TestClock;

impl TestClock {
    /// Checks whether `self` was requested to provide the clock notification
    /// given by `id`.
    ///
    /// MT safe.
    /// ## `id`
    /// a `gst::ClockID` clock notification
    ///
    /// # Returns
    ///
    /// `true` if the clock has been asked to provide the given clock
    /// notification, `false` otherwise.
    pub fn has_id(&self, id: &gst::ClockId) -> bool {
        unsafe {
            from_glib(gst_check_sys::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.
    /// ## `pending_id`
    /// a `gst::ClockID` clock
    /// notification to look for
    ///
    /// # Returns
    ///
    /// `true` if `pending_id` is the next clock notification to be
    /// triggered, `false` otherwise.
    pub fn peek_next_pending_id(&self) -> Option<gst::ClockId> {
        unsafe {
            let mut id = ptr::null_mut();
            let ret: bool = from_glib(gst_check_sys::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.
    ///
    /// Feature: `v1_18`
    ///
    /// ## `pending_id`
    /// `gst::ClockID`
    #[cfg(any(feature = "v1_18", feature = "dox"))]
    pub fn process_id(&self, pending_id: &gst::ClockId) -> bool {
        unsafe {
            from_glib(gst_check_sys::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`
    pub fn process_id_list(&self, pending_list: &[&gst::ClockId]) -> u32 {
        unsafe {
            gst_check_sys::gst_test_clock_process_id_list(
                self.to_glib_none().0,
                pending_list.to_glib_none().0,
            )
        }
    }

    /// MT safe.
    ///
    /// # Returns
    ///
    /// a `gst::ClockID` containing the next pending clock
    /// notification.
    pub fn process_next_clock_id(&self) -> Option<gst::ClockId> {
        unsafe {
            from_glib_full(gst_check_sys::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`.
    ///
    /// MT safe.
    /// ## `count`
    /// the number of pending clock notifications to wait for
    /// ## `pending_list`
    /// Address
    ///  of a `glib::List` pointer variable to store the list of pending `GstClockIDs`
    ///  that expired, or `None`
    pub fn wait_for_multiple_pending_ids(&self, count: u32) -> Vec<gst::ClockId> {
        unsafe {
            let mut pending_list = ptr::null_mut();
            gst_check_sys::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`. A reference
    /// to the pending clock notification is stored in `pending_id`.
    ///
    /// MT safe.
    /// ## `pending_id`
    /// `gst::ClockID`
    /// with information about the pending clock notification
    pub fn wait_for_next_pending_id(&self) -> gst::ClockId {
        unsafe {
            let mut id = ptr::null_mut();
            gst_check_sys::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.
    ///
    /// Feature: `v1_16`
    ///
    /// ## `count`
    /// the number of pending clock notifications to wait for
    /// ## `timeout_ms`
    /// the timeout in milliseconds
    /// ## `pending_list`
    /// Address
    ///  of a `glib::List` pointer variable to store the list of pending `GstClockIDs`
    ///  that expired, or `None`
    ///
    /// # 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)
    #[cfg(any(feature = "v1_16", feature = "dox"))]
    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 = gst_check_sys::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),
            )
        }
    }
}