// 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 MIKEYEncAlg;
use MIKEYKeyDataType;
use MIKEYMacAlg;
use MIKEYPayloadType;
use MIKEYSecProto;
use ffi;
use glib::translate::*;
use glib_ffi;
use gobject_ffi;
use std::mem;
use std::ptr;

glib_wrapper! {
    /// Hold the common fields for all payloads
    #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct MIKEYPayload(Boxed<ffi::GstMIKEYPayload>);

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

impl MIKEYPayload {
    /// Make a new `MIKEYPayload` with `type_`.
    /// ## `type_`
    /// a `MIKEYPayloadType`
    ///
    /// # Returns
    ///
    /// a new `MIKEYPayload` or `None` on failure.
    pub fn new(type_: MIKEYPayloadType) -> MIKEYPayload {
        assert_initialized_main_thread!();
        unsafe {
            from_glib_full(ffi::gst_mikey_payload_new(type_.to_glib()))
        }
    }

    /// Get the number of sub payloads of `self`. `self` should be of type
    /// `MIKEYPayloadType::Kemac`.
    ///
    /// # Returns
    ///
    /// the number of sub payloads in `self`
    pub fn kemac_get_n_sub(&self) -> u32 {
        unsafe {
            ffi::gst_mikey_payload_kemac_get_n_sub(self.to_glib_none().0)
        }
    }

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

    /// Set the KEMAC parameters. `self` should point to a `MIKEYPayloadType::Kemac`
    /// payload.
    /// ## `enc_alg`
    /// the `MIKEYEncAlg`
    /// ## `mac_alg`
    /// a `MIKEYMacAlg`
    ///
    /// # Returns
    ///
    /// `true` on success
    pub fn kemac_set(&mut self, enc_alg: MIKEYEncAlg, mac_alg: MIKEYMacAlg) -> bool {
        unsafe {
            from_glib(ffi::gst_mikey_payload_kemac_set(self.to_glib_none_mut().0, enc_alg.to_glib(), mac_alg.to_glib()))
        }
    }

    /// Set `key_len` bytes of `key_data` of type `key_type` as the key for the
    /// `MIKEYPayloadType::KeyData` `self`.
    /// ## `key_type`
    /// a `MIKEYKeyDataType`
    /// ## `key_len`
    /// the length of `key_data`
    /// ## `key_data`
    /// the key of type `key_type`
    ///
    /// # Returns
    ///
    /// `true` on success
    pub fn key_data_set_key(&mut self, key_type: MIKEYKeyDataType, key_data: &[u8]) -> bool {
        let key_len = key_data.len() as u16;
        unsafe {
            from_glib(ffi::gst_mikey_payload_key_data_set_key(self.to_glib_none_mut().0, key_type.to_glib(), key_len, key_data.to_glib_none().0))
        }
    }

    /// Set the salt key data. If `salt_len` is 0 and `salt_data` is `None`, the
    /// salt data will be removed.
    /// ## `salt_len`
    /// the length of `salt_data`
    /// ## `salt_data`
    /// the salt
    ///
    /// # Returns
    ///
    /// `true` on success
    pub fn key_data_set_salt(&mut self, salt_data: &[u8]) -> bool {
        let salt_len = salt_data.len() as u16;
        unsafe {
            from_glib(ffi::gst_mikey_payload_key_data_set_salt(self.to_glib_none_mut().0, salt_len, salt_data.to_glib_none().0))
        }
    }

    /// Set the SPI/MKI validity in the `MIKEYPayloadType::KeyData` `self`.
    /// ## `spi_len`
    /// the length of `spi_data`
    /// ## `spi_data`
    /// the SPI/MKI data
    ///
    /// # Returns
    ///
    /// `true` on success
    pub fn key_data_set_spi(&mut self, spi_data: &[u8]) -> bool {
        let spi_len = spi_data.len() as u8;
        unsafe {
            from_glib(ffi::gst_mikey_payload_key_data_set_spi(self.to_glib_none_mut().0, spi_len, spi_data.to_glib_none().0))
        }
    }

    /// Set the PKE values in `self`. `self` must be of type
    /// `MIKEYPayloadType::Pke`.
    /// ## `C`
    /// envelope key cache indicator
    /// ## `data_len`
    /// the length of `data`
    /// ## `data`
    /// the encrypted envelope key
    ///
    /// # Returns
    ///
    /// `true` on success
    pub fn pke_set(&mut self, C: MIKEYCacheType, data: &[u8]) -> bool {
        let data_len = data.len() as u16;
        unsafe {
            from_glib(ffi::gst_mikey_payload_pke_set(self.to_glib_none_mut().0, C.to_glib(), data_len, data.to_glib_none().0))
        }
    }

    /// Set the random values in a `MIKEYPayloadType::Rand` `self`.
    /// ## `len`
    /// the length of `rand`
    /// ## `rand`
    /// random values
    ///
    /// # Returns
    ///
    /// `true` on success
    pub fn rand_set(&mut self, rand: &[u8]) -> bool {
        let len = rand.len() as u8;
        unsafe {
            from_glib(ffi::gst_mikey_payload_rand_set(self.to_glib_none_mut().0, len, rand.to_glib_none().0))
        }
    }

    /// Add a new parameter to the `MIKEYPayloadType::Sp` `self` with `type_`, `len`
    /// and `val`.
    /// ## `type_`
    /// a type
    /// ## `len`
    /// a length
    /// ## `val`
    /// `len` bytes of data
    ///
    /// # Returns
    ///
    /// `true` on success
    pub fn sp_add_param(&mut self, type_: u8, val: &[u8]) -> bool {
        let len = val.len() as u8;
        unsafe {
            from_glib(ffi::gst_mikey_payload_sp_add_param(self.to_glib_none_mut().0, type_, len, val.to_glib_none().0))
        }
    }

    /// Get the number of security policy parameters in a `MIKEYPayloadType::Sp`
    /// `self`.
    ///
    /// # Returns
    ///
    /// the number of parameters in `self`
    pub fn sp_get_n_params(&self) -> u32 {
        unsafe {
            ffi::gst_mikey_payload_sp_get_n_params(self.to_glib_none().0)
        }
    }

    //pub fn sp_get_param(&self, idx: u32) -> /*Ignored*/Option<MIKEYPayloadSPParam> {
    //    unsafe { TODO: call ffi::gst_mikey_payload_sp_get_param() }
    //}

    /// Remove the Security Policy parameters from a `MIKEYPayloadType::Sp`
    /// `self` at `idx`.
    /// ## `idx`
    /// an index
    ///
    /// # Returns
    ///
    /// `true` on success
    pub fn sp_remove_param(&mut self, idx: u32) -> bool {
        unsafe {
            from_glib(ffi::gst_mikey_payload_sp_remove_param(self.to_glib_none_mut().0, idx))
        }
    }

    /// Set the Security Policy parameters for `self`.
    /// ## `policy`
    /// the policy number
    /// ## `proto`
    /// a `MIKEYSecProto`
    ///
    /// # Returns
    ///
    /// `true` on success
    pub fn sp_set(&mut self, policy: u32, proto: MIKEYSecProto) -> bool {
        unsafe {
            from_glib(ffi::gst_mikey_payload_sp_set(self.to_glib_none_mut().0, policy, proto.to_glib()))
        }
    }

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

unsafe impl Send for MIKEYPayload {}