// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

use MIKEYCacheType;
use MIKEYMapType;
use MIKEYPRFFunc;
use MIKEYPayload;
use MIKEYPayloadType;
use MIKEYType;
use ffi;
use glib::translate::*;
use glib_ffi;
use gobject_ffi;
use gst;
use std::mem;
use std::ptr;

glib_wrapper! {
    /// Structure holding the information of the MIKEY message
    #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct MIKEYMessage(Boxed<ffi::GstMIKEYMessage>);

    match fn {
        copy => |ptr| gobject_ffi::g_boxed_copy(ffi::gst_mikey_message_get_type(), ptr as *mut _) as *mut ffi::GstMIKEYMessage,
        free => |ptr| gobject_ffi::g_boxed_free(ffi::gst_mikey_message_get_type(), ptr as *mut _),
        get_type => || ffi::gst_mikey_message_get_type(),
    }
}

impl MIKEYMessage {
    /// Make a new MIKEY message.
    ///
    /// # Returns
    ///
    /// a new `MIKEYMessage` on success
    pub fn new() -> MIKEYMessage {
        assert_initialized_main_thread!();
        unsafe {
            from_glib_full(ffi::gst_mikey_message_new())
        }
    }

    //pub fn new_from_bytes(bytes: &glib::Bytes, info: /*Ignored*/&mut MIKEYDecryptInfo, error: /*Ignored*/Option<Error>) -> MIKEYMessage {
    //    unsafe { TODO: call ffi::gst_mikey_message_new_from_bytes() }
    //}

    /// Makes mikey message including:
    ///  - Security Policy Payload
    ///  - Key Data Transport Payload
    ///  - Key Data Sub-Payload
    /// ## `caps`
    /// a `gst::Caps`, including SRTP parameters (srtp/srtcp cipher, authorization, key data)
    ///
    /// # Returns
    ///
    /// a `MIKEYMessage`,
    /// or `None` if there is no srtp information in the caps.
    pub fn new_from_caps(caps: &gst::Caps) -> MIKEYMessage {
        assert_initialized_main_thread!();
        unsafe {
            from_glib_full(ffi::gst_mikey_message_new_from_caps(caps.to_glib_none().0))
        }
    }

    //pub fn new_from_data(data: &[u8], info: /*Ignored*/&mut MIKEYDecryptInfo, error: /*Ignored*/Option<Error>) -> MIKEYMessage {
    //    unsafe { TODO: call ffi::gst_mikey_message_new_from_data() }
    //}

    /// Add a Crypto policy for SRTP to `self`.
    /// ## `policy`
    /// The security policy applied for the stream with `ssrc`
    /// ## `ssrc`
    /// the SSRC that must be used for the stream
    /// ## `roc`
    /// current rollover counter
    ///
    /// # Returns
    ///
    /// `true` on success
    pub fn add_cs_srtp(&mut self, policy: u8, ssrc: u32, roc: u32) -> bool {
        unsafe {
            from_glib(ffi::gst_mikey_message_add_cs_srtp(self.to_glib_none_mut().0, policy, ssrc, roc))
        }
    }

    /// Add a new PKE payload to `self` with the given parameters.
    /// ## `C`
    /// envelope key cache indicator
    /// ## `data_len`
    /// the length of `data`
    /// ## `data`
    /// the encrypted envelope key
    ///
    /// # Returns
    ///
    /// `true` on success
    pub fn add_pke(&mut self, C: MIKEYCacheType, data: &[u8]) -> bool {
        let data_len = data.len() as u16;
        unsafe {
            from_glib(ffi::gst_mikey_message_add_pke(self.to_glib_none_mut().0, C.to_glib(), data_len, data.to_glib_none().0))
        }
    }

    /// Add a new RAND payload to `self` with the given parameters.
    /// ## `len`
    /// the length of `rand`
    /// ## `rand`
    /// random data
    ///
    /// # Returns
    ///
    /// `true` on success
    pub fn add_rand(&mut self, rand: &[u8]) -> bool {
        let len = rand.len() as u8;
        unsafe {
            from_glib(ffi::gst_mikey_message_add_rand(self.to_glib_none_mut().0, len, rand.to_glib_none().0))
        }
    }

    /// Add a new RAND payload to `self` with `len` random bytes.
    /// ## `len`
    /// length
    ///
    /// # Returns
    ///
    /// `true` on success
    pub fn add_rand_len(&mut self, len: u8) -> bool {
        unsafe {
            from_glib(ffi::gst_mikey_message_add_rand_len(self.to_glib_none_mut().0, len))
        }
    }

    //pub fn add_t(&mut self, type_: MIKEYTSType, ts_value: &[u8]) -> bool {
    //    unsafe { TODO: call ffi::gst_mikey_message_add_t() }
    //}

    /// Add a new T payload to `self` that contains the current time
    /// in NTP-UTC format.
    ///
    /// # Returns
    ///
    /// `true` on success
    pub fn add_t_now_ntp_utc(&mut self) -> bool {
        unsafe {
            from_glib(ffi::gst_mikey_message_add_t_now_ntp_utc(self.to_glib_none_mut().0))
        }
    }

    /// Find the `nth` occurence of the payload with `type_` in `self`.
    /// ## `type_`
    /// a `MIKEYPayloadType`
    /// ## `nth`
    /// payload to find
    ///
    /// # Returns
    ///
    /// the `nth` `MIKEYPayload` of `type_`.
    pub fn find_payload(&self, type_: MIKEYPayloadType, nth: u32) -> Option<MIKEYPayload> {
        unsafe {
            from_glib_none(ffi::gst_mikey_message_find_payload(self.to_glib_none().0, type_.to_glib(), nth))
        }
    }

    //pub fn get_cs_srtp(&self, idx: u32) -> /*Ignored*/Option<MIKEYMapSRTP> {
    //    unsafe { TODO: call ffi::gst_mikey_message_get_cs_srtp() }
    //}

    /// Get the number of crypto sessions in `self`.
    ///
    /// # Returns
    ///
    /// the number of crypto sessions
    pub fn get_n_cs(&self) -> u32 {
        unsafe {
            ffi::gst_mikey_message_get_n_cs(self.to_glib_none().0)
        }
    }

    /// Get the number of payloads in `self`.
    ///
    /// # Returns
    ///
    /// the number of payloads in `self`
    pub fn get_n_payloads(&self) -> u32 {
        unsafe {
            ffi::gst_mikey_message_get_n_payloads(self.to_glib_none().0)
        }
    }

    //pub fn insert_cs_srtp(&mut self, idx: i32, map: /*Ignored*/&MIKEYMapSRTP) -> bool {
    //    unsafe { TODO: call ffi::gst_mikey_message_insert_cs_srtp() }
    //}

    /// Remove the SRTP policy at `idx`.
    /// ## `idx`
    /// the index to remove
    ///
    /// # Returns
    ///
    /// `true` on success
    pub fn remove_cs_srtp(&mut self, idx: i32) -> bool {
        unsafe {
            from_glib(ffi::gst_mikey_message_remove_cs_srtp(self.to_glib_none_mut().0, idx))
        }
    }

    /// Remove the payload in `self` at `idx`
    /// ## `idx`
    /// an index
    ///
    /// # Returns
    ///
    /// `true` on success
    pub fn remove_payload(&mut self, idx: u32) -> bool {
        unsafe {
            from_glib(ffi::gst_mikey_message_remove_payload(self.to_glib_none_mut().0, idx))
        }
    }

    //pub fn replace_cs_srtp(&mut self, idx: i32, map: /*Ignored*/&MIKEYMapSRTP) -> bool {
    //    unsafe { TODO: call ffi::gst_mikey_message_replace_cs_srtp() }
    //}

    /// Set the information in `self`.
    /// ## `version`
    /// a version
    /// ## `type_`
    /// a `MIKEYType`
    /// ## `V`
    /// verify flag
    /// ## `prf_func`
    /// the `MIKEYPRFFunc` function to use
    /// ## `CSB_id`
    /// the Crypto Session Bundle id
    /// ## `map_type`
    /// the `GstMIKEYCSIDMapType`
    ///
    /// # Returns
    ///
    /// `true` on success
    pub fn set_info(&mut self, version: u8, type_: MIKEYType, V: bool, prf_func: MIKEYPRFFunc, CSB_id: u32, map_type: MIKEYMapType) -> bool {
        unsafe {
            from_glib(ffi::gst_mikey_message_set_info(self.to_glib_none_mut().0, version, type_.to_glib(), V.to_glib(), prf_func.to_glib(), CSB_id, map_type.to_glib()))
        }
    }

    //pub fn to_bytes(&mut self, info: /*Ignored*/&mut MIKEYEncryptInfo, error: /*Ignored*/Option<Error>) -> Option<glib::Bytes> {
    //    unsafe { TODO: call ffi::gst_mikey_message_to_bytes() }
    //}

    ///
    /// Feature: `v1_8_1`
    ///
    /// ## `caps`
    /// a `gst::Caps` to be filled with SRTP parameters (srtp/srtcp cipher, authorization, key data)
    ///
    /// # Returns
    ///
    /// `true` on success
    #[cfg(any(feature = "v1_8_1", feature = "dox"))]
    pub fn to_caps(&self, caps: &gst::Caps) -> bool {
        unsafe {
            from_glib(ffi::gst_mikey_message_to_caps(self.to_glib_none().0, caps.to_glib_none().0))
        }
    }
}

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

unsafe impl Send for MIKEYMessage {}