// Copyright (C) 2017 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::object::IsA;
use glib::translate::*;
use gobject_sys;
use gst;
use gst_base_sys;

glib_wrapper! {
    /// Utility struct to help handling `gst::FlowReturn` combination. Useful for
    /// `gst::Element`<!-- -->s that have multiple source pads and need to combine
    /// the different `gst::FlowReturn` for those pads.
    ///
    /// `FlowCombiner` works by using the last `gst::FlowReturn` for all `gst::Pad`
    /// it has in its list and computes the combined return value and provides
    /// it to the caller.
    ///
    /// To add a new pad to the `FlowCombiner` use `FlowCombiner::add_pad`.
    /// The new `gst::Pad` is stored with a default value of `gst::FlowReturn::Ok`.
    ///
    /// In case you want a `gst::Pad` to be removed, use `FlowCombiner::remove_pad`.
    ///
    /// Please be aware that this struct isn't thread safe as its designed to be
    ///  used by demuxers, those usually will have a single thread operating it.
    ///
    /// These functions will take refs on the passed `gst::Pad`<!-- -->s.
    ///
    /// Aside from reducing the user's code size, the main advantage of using this
    /// helper struct is to follow the standard rules for `gst::FlowReturn` combination.
    /// These rules are:
    ///
    /// * `gst::FlowReturn::Eos`: only if all returns are EOS too
    /// * `gst::FlowReturn::NotLinked`: only if all returns are NOT_LINKED too
    /// * `gst::FlowReturn::Error` or below: if at least one returns an error return
    /// * `gst::FlowReturn::NotNegotiated`: if at least one returns a not-negotiated return
    /// * `gst::FlowReturn::Flushing`: if at least one returns flushing
    /// * `gst::FlowReturn::Ok`: otherwise
    ///
    /// `gst::FlowReturn::Error` or below, GST_FLOW_NOT_NEGOTIATED and GST_FLOW_FLUSHING are
    /// returned immediately from the `FlowCombiner::update_flow` function.
    #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct FlowCombiner(Shared<gst_base_sys::GstFlowCombiner>);

    match fn {
        ref => |ptr| gobject_sys::g_boxed_copy(gst_base_sys::gst_flow_combiner_get_type(), ptr as *mut _),
        unref => |ptr| gobject_sys::g_boxed_free(gst_base_sys::gst_flow_combiner_get_type(), ptr as *mut _),
        get_type => || gst_base_sys::gst_flow_combiner_get_type(),
    }
}

impl FlowCombiner {
    /// Creates a new `FlowCombiner`, use `FlowCombiner::free` to free it.
    ///
    /// # Returns
    ///
    /// A new `FlowCombiner`
    pub fn new() -> FlowCombiner {
        assert_initialized_main_thread!();
        unsafe { from_glib_full(gst_base_sys::gst_flow_combiner_new()) }
    }

    /// Adds a new `gst::Pad` to the `FlowCombiner`.
    /// ## `pad`
    /// the `gst::Pad` that is being added
    pub fn add_pad<P: IsA<gst::Pad>>(&self, pad: &P) {
        unsafe {
            gst_base_sys::gst_flow_combiner_add_pad(
                self.to_glib_none().0,
                pad.as_ref().to_glib_none().0,
            );
        }
    }

    /// Removes all pads from a `FlowCombiner` and resets it to its initial state.
    pub fn clear(&self) {
        unsafe {
            gst_base_sys::gst_flow_combiner_clear(self.to_glib_none().0);
        }
    }

    /// Removes a `gst::Pad` from the `FlowCombiner`.
    /// ## `pad`
    /// the `gst::Pad` to remove
    pub fn remove_pad<P: IsA<gst::Pad>>(&self, pad: &P) {
        unsafe {
            gst_base_sys::gst_flow_combiner_remove_pad(
                self.to_glib_none().0,
                pad.as_ref().to_glib_none().0,
            );
        }
    }

    /// Reset flow combiner and all pads to their initial state without removing pads.
    pub fn reset(&self) {
        unsafe {
            gst_base_sys::gst_flow_combiner_reset(self.to_glib_none().0);
        }
    }

    /// Computes the combined flow return for the pads in it.
    ///
    /// The `gst::FlowReturn` parameter should be the last flow return update for a pad
    /// in this `FlowCombiner`. It will use this value to be able to shortcut some
    /// combinations and avoid looking over all pads again. e.g. The last combined
    /// return is the same as the latest obtained `gst::FlowReturn`.
    /// ## `fret`
    /// the latest `gst::FlowReturn` received for a pad in this `FlowCombiner`
    ///
    /// # Returns
    ///
    /// The combined `gst::FlowReturn`
    pub fn update_flow<FRet: Into<gst::FlowReturn>>(
        &self,
        fret: FRet,
    ) -> Result<gst::FlowSuccess, gst::FlowError> {
        let fret: gst::FlowReturn = fret.into();
        let ret: gst::FlowReturn = unsafe {
            from_glib(gst_base_sys::gst_flow_combiner_update_flow(
                self.to_glib_none().0,
                fret.to_glib(),
            ))
        };
        ret.into_result()
    }

    /// Sets the provided pad's last flow return to provided value and computes
    /// the combined flow return for the pads in it.
    ///
    /// The `gst::FlowReturn` parameter should be the last flow return update for a pad
    /// in this `FlowCombiner`. It will use this value to be able to shortcut some
    /// combinations and avoid looking over all pads again. e.g. The last combined
    /// return is the same as the latest obtained `gst::FlowReturn`.
    /// ## `pad`
    /// the `gst::Pad` whose `gst::FlowReturn` to update
    /// ## `fret`
    /// the latest `gst::FlowReturn` received for a pad in this `FlowCombiner`
    ///
    /// # Returns
    ///
    /// The combined `gst::FlowReturn`
    pub fn update_pad_flow<P: IsA<gst::Pad>, FRet: Into<gst::FlowReturn>>(
        &self,
        pad: &P,
        fret: FRet,
    ) -> Result<gst::FlowSuccess, gst::FlowError> {
        let fret: gst::FlowReturn = fret.into();
        let ret: gst::FlowReturn = unsafe {
            from_glib(gst_base_sys::gst_flow_combiner_update_pad_flow(
                self.to_glib_none().0,
                pad.as_ref().to_glib_none().0,
                fret.to_glib(),
            ))
        };
        ret.into_result()
    }
}

impl Default for FlowCombiner {
    fn default() -> Self {
        Self::new()
    }
}

#[derive(Debug)]
pub struct UniqueFlowCombiner(FlowCombiner);

unsafe impl Sync for UniqueFlowCombiner {}
unsafe impl Send for UniqueFlowCombiner {}

impl UniqueFlowCombiner {
    pub fn new() -> UniqueFlowCombiner {
        UniqueFlowCombiner(FlowCombiner::new())
    }

    pub fn add_pad<P: IsA<gst::Pad>>(&mut self, pad: &P) {
        self.0.add_pad(pad);
    }

    pub fn clear(&mut self) {
        self.0.clear();
    }

    pub fn remove_pad<P: IsA<gst::Pad>>(&mut self, pad: &P) {
        self.0.remove_pad(pad);
    }

    pub fn reset(&mut self) {
        self.0.reset();
    }

    pub fn update_flow(
        &mut self,
        fret: Result<gst::FlowSuccess, gst::FlowError>,
    ) -> Result<gst::FlowSuccess, gst::FlowError> {
        self.0.update_flow(fret)
    }

    pub fn update_pad_flow<P: IsA<gst::Pad>>(
        &mut self,
        pad: &P,
        fret: Result<gst::FlowSuccess, gst::FlowError>,
    ) -> Result<gst::FlowSuccess, gst::FlowError> {
        self.0.update_pad_flow(pad, fret)
    }
}

impl Default for UniqueFlowCombiner {
    fn default() -> Self {
        Self::new()
    }
}