// 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 ffi;
use glib::translate::*;
use glib_ffi;
use gobject_ffi;
use std::mem;
use std::ptr;
use PromiseResult;
use Structure;
use StructureRef;

glib_wrapper! {
    /// The `Promise` object implements the container for values that may
    /// be available later. i.e. a Future or a Promise in
    /// <ulink url="https://en.wikipedia.org/wiki/Futures_and_promises">https://en.wikipedia.org/wiki/Futures_and_promises`</ulink>`
    /// As with all Future/Promise-like functionality, there is the concept of the
    /// producer of the value and the consumer of the value.
    ///
    /// A `Promise` is created with `Promise::new` by the consumer and passed
    /// to the producer to avoid thread safety issues with the change callback.
    /// A `Promise` can be replied to with a value (or an error) by the producer
    /// with `Promise::reply`. `Promise::interrupt` is for the consumer to
    /// indicate to the producer that the value is not needed anymore and producing
    /// that value can stop. The `PromiseResult::Expired` state set by a call
    /// to `Promise::expire` indicates to the consumer that a value will never
    /// be produced and is intended to be called by a third party that implements
    /// some notion of message handling such as `Bus`.
    /// A callback can also be installed at `Promise` creation for
    /// result changes with `Promise::new_with_change_func`.
    /// The change callback can be used to chain `GstPromises`'s together as in the
    /// following example.
    ///
    /// ```C
    /// const GstStructure *reply;
    /// GstPromise *p;
    /// if (gst_promise_wait (promise) != GST_PROMISE_RESULT_REPLIED)
    ///   return; // interrupted or expired value
    /// reply = gst_promise_get_reply (promise);
    /// if (error in reply)
    ///   return; // propagate error
    /// p = gst_promise_new_with_change_func (another_promise_change_func, user_data, notify);
    /// pass p to promise-using API
    /// ```
    ///
    /// Each `Promise` starts out with a `PromiseResult` of
    /// `PromiseResult::Pending` and only ever transitions once
    /// into one of the other `PromiseResult`'s.
    ///
    /// In order to support multi-threaded code, `Promise::reply`,
    /// `Promise::interrupt` and `Promise::expire` may all be from
    /// different threads with some restrictions and the final result of the promise
    /// is whichever call is made first. There are two restrictions on ordering:
    ///
    /// 1. That `Promise::reply` and `Promise::interrupt` cannot be called
    /// after `Promise::expire`
    /// 2. That `Promise::reply` and `Promise::interrupt`
    /// cannot be called twice.
    ///
    /// The change function set with `Promise::new_with_change_func` is
    /// called directly from either the `Promise::reply`,
    /// `Promise::interrupt` or `Promise::expire` and can be called
    /// from an arbitrary thread. `Promise` using APIs can restrict this to
    /// a single thread or a subset of threads but that is entirely up to the API
    /// that uses `Promise`.
    ///
    /// Feature: `v1_14`
    pub struct Promise(Shared<ffi::GstPromise>);

    match fn {
        ref => |ptr| ffi::gst_mini_object_ref(ptr as *mut _),
        unref => |ptr| ffi::gst_mini_object_unref(ptr as *mut _),
        get_type => || ffi::gst_promise_get_type(),
    }
}

impl Promise {
    ///
    /// Feature: `v1_14`
    ///
    ///
    /// # Returns
    ///
    /// a new `Promise`
    #[cfg(any(feature = "v1_14", feature = "dox"))]
    pub fn new() -> Promise {
        assert_initialized_main_thread!();
        unsafe { from_glib_full(ffi::gst_promise_new()) }
    }

    /// `func` will be called exactly once when transitioning out of
    /// `PromiseResult::Pending` into any of the other `PromiseResult`
    /// states.
    ///
    /// Feature: `v1_14`
    ///
    /// ## `func`
    /// a `GstPromiseChangeFunc` to call
    /// ## `user_data`
    /// argument to call `func` with
    /// ## `notify`
    /// notification function that `user_data` is no longer needed
    ///
    /// # Returns
    ///
    /// a new `Promise`
    #[cfg(any(feature = "v1_14", feature = "dox"))]
    pub fn new_with_change_func<F>(func: F) -> Promise
    where
        F: FnOnce(&Promise) + Send + 'static,
    {
        let user_data: Box<Option<Box<F>>> = Box::new(Some(Box::new(func)));

        unsafe extern "C" fn trampoline<F: FnOnce(&Promise) + Send + 'static>(
            promise: *mut ffi::GstPromise,
            user_data: glib_ffi::gpointer,
        ) {
            let user_data: &mut Option<Box<F>> = &mut *(user_data as *mut _);
            let callback = user_data.take().unwrap();

            callback(&from_glib_borrow(promise));
        }

        unsafe extern "C" fn free_user_data<F: FnOnce(&Promise) + Send + 'static>(
            user_data: glib_ffi::gpointer,
        ) {
            let _: Box<Option<Box<F>>> = Box::from_raw(user_data as *mut _);
        }

        let trampoline = trampoline::<F>;
        let free_user_data = free_user_data::<F>;
        unsafe {
            from_glib_full(ffi::gst_promise_new_with_change_func(
                Some(trampoline),
                Box::into_raw(user_data) as *mut _,
                Some(free_user_data),
            ))
        }
    }

    /// Expire a `self`. This will wake up any waiters with
    /// `PromiseResult::Expired`. Called by a message loop when the parent
    /// message is handled and/or destroyed (possibly unanswered).
    ///
    /// Feature: `v1_14`
    ///
    #[cfg(any(feature = "v1_14", feature = "dox"))]
    pub fn expire(&self) {
        unsafe {
            ffi::gst_promise_expire(self.to_glib_none().0);
        }
    }

    /// Retrieve the reply set on `self`. `self` must be in
    /// `PromiseResult::Replied` and the returned structure is owned by `self`
    ///
    /// Feature: `v1_14`
    ///
    ///
    /// # Returns
    ///
    /// The reply set on `self`
    #[cfg(any(feature = "v1_14", feature = "dox"))]
    pub fn get_reply(&self) -> Option<&StructureRef> {
        unsafe {
            let s = ffi::gst_promise_get_reply(self.to_glib_none().0);
            if s.is_null() {
                None
            } else {
                Some(StructureRef::from_glib_borrow(s))
            }
        }
    }

    /// Interrupt waiting for a `self`. This will wake up any waiters with
    /// `PromiseResult::Interrupted`. Called when the consumer does not want
    /// the value produced anymore.
    ///
    /// Feature: `v1_14`
    ///
    #[cfg(any(feature = "v1_14", feature = "dox"))]
    pub fn interrupt(&self) {
        unsafe {
            ffi::gst_promise_interrupt(self.to_glib_none().0);
        }
    }

    /// Set a reply on `self`. This will wake up any waiters with
    /// `PromiseResult::Replied`. Called by the producer of the value to
    /// indicate success (or failure).
    ///
    /// If `self` has already been interrupted by the consumer, then this reply
    /// is not visible to the consumer.
    ///
    /// Feature: `v1_14`
    ///
    /// ## `s`
    /// a `Structure` with the the reply contents
    #[cfg(any(feature = "v1_14", feature = "dox"))]
    pub fn reply(&self, s: Structure) {
        unsafe {
            ffi::gst_promise_reply(self.to_glib_none().0, s.into_ptr());
        }
    }

    /// Wait for `self` to move out of the `PromiseResult::Pending` state.
    /// If `self` is not in `PromiseResult::Pending` then it will return
    /// immediately with the current result.
    ///
    /// Feature: `v1_14`
    ///
    ///
    /// # Returns
    ///
    /// the result of the promise
    #[cfg(any(feature = "v1_14", feature = "dox"))]
    pub fn wait(&self) -> PromiseResult {
        unsafe { from_glib(ffi::gst_promise_wait(self.to_glib_none().0)) }
    }
}

#[cfg(any(feature = "v1_14", feature = "dox"))]
impl Default for Promise {
    fn default() -> Self {
        Self::new()
    }
}

unsafe impl Send for Promise {}
unsafe impl Sync for Promise {}