// 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 crate::File;
use glib::{prelude::*, translate::*};
use std::{boxed::Box as Box_, fmt};

glib::wrapper! {
    /// Entry point for using GIO functionality.
    ///
    /// # Implements
    ///
    /// [`VfsExt`][trait@crate::prelude::VfsExt], [`trait@glib::ObjectExt`]
    #[doc(alias = "GVfs")]
    pub struct Vfs(Object<ffi::GVfs, ffi::GVfsClass>);

    match fn {
        type_ => || ffi::g_vfs_get_type(),
    }
}

impl Vfs {
    pub const NONE: Option<&'static Vfs> = None;

    /// Gets the default [`Vfs`][crate::Vfs] for the system.
    ///
    /// # Returns
    ///
    /// a [`Vfs`][crate::Vfs], which will be the local
    ///  file system [`Vfs`][crate::Vfs] if no other implementation is available.
    #[doc(alias = "g_vfs_get_default")]
    #[doc(alias = "get_default")]
    #[allow(clippy::should_implement_trait)]
    pub fn default() -> Vfs {
        unsafe { from_glib_none(ffi::g_vfs_get_default()) }
    }

    /// Gets the local [`Vfs`][crate::Vfs] for the system.
    ///
    /// # Returns
    ///
    /// a [`Vfs`][crate::Vfs].
    #[doc(alias = "g_vfs_get_local")]
    #[doc(alias = "get_local")]
    pub fn local() -> Vfs {
        unsafe { from_glib_none(ffi::g_vfs_get_local()) }
    }
}

unsafe impl Send for Vfs {}
unsafe impl Sync for Vfs {}

mod sealed {
    pub trait Sealed {}
    impl<T: super::IsA<super::Vfs>> Sealed for T {}
}

/// Trait containing all [`struct@Vfs`] methods.
///
/// # Implementors
///
/// [`Vfs`][struct@crate::Vfs]
pub trait VfsExt: IsA<Vfs> + sealed::Sealed + 'static {
    /// Gets a [`File`][crate::File] for `path`.
    /// ## `path`
    /// a string containing a VFS path.
    ///
    /// # Returns
    ///
    /// a [`File`][crate::File].
    ///  Free the returned object with `g_object_unref()`.
    #[doc(alias = "g_vfs_get_file_for_path")]
    #[doc(alias = "get_file_for_path")]
    fn file_for_path(&self, path: &str) -> File {
        unsafe {
            from_glib_full(ffi::g_vfs_get_file_for_path(
                self.as_ref().to_glib_none().0,
                path.to_glib_none().0,
            ))
        }
    }

    /// Gets a [`File`][crate::File] for `uri`.
    ///
    /// This operation never fails, but the returned object
    /// might not support any I/O operation if the URI
    /// is malformed or if the URI scheme is not supported.
    /// ## `uri`
    /// a string containing a URI
    ///
    /// # Returns
    ///
    /// a [`File`][crate::File].
    ///  Free the returned object with `g_object_unref()`.
    #[doc(alias = "g_vfs_get_file_for_uri")]
    #[doc(alias = "get_file_for_uri")]
    fn file_for_uri(&self, uri: &str) -> File {
        unsafe {
            from_glib_full(ffi::g_vfs_get_file_for_uri(
                self.as_ref().to_glib_none().0,
                uri.to_glib_none().0,
            ))
        }
    }

    /// Gets a list of URI schemes supported by `self`.
    ///
    /// # Returns
    ///
    /// a [`None`]-terminated array of strings.
    ///  The returned array belongs to GIO and must
    ///  not be freed or modified.
    #[doc(alias = "g_vfs_get_supported_uri_schemes")]
    #[doc(alias = "get_supported_uri_schemes")]
    fn supported_uri_schemes(&self) -> Vec<glib::GString> {
        unsafe {
            FromGlibPtrContainer::from_glib_none(ffi::g_vfs_get_supported_uri_schemes(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Checks if the VFS is active.
    ///
    /// # Returns
    ///
    /// [`true`] if construction of the `self` was successful
    ///  and it is now active.
    #[doc(alias = "g_vfs_is_active")]
    fn is_active(&self) -> bool {
        unsafe { from_glib(ffi::g_vfs_is_active(self.as_ref().to_glib_none().0)) }
    }

    /// This operation never fails, but the returned object might
    /// not support any I/O operations if the `parse_name` cannot
    /// be parsed by the [`Vfs`][crate::Vfs] module.
    /// ## `parse_name`
    /// a string to be parsed by the VFS module.
    ///
    /// # Returns
    ///
    /// a [`File`][crate::File] for the given `parse_name`.
    ///  Free the returned object with `g_object_unref()`.
    #[doc(alias = "g_vfs_parse_name")]
    fn parse_name(&self, parse_name: &str) -> File {
        unsafe {
            from_glib_full(ffi::g_vfs_parse_name(
                self.as_ref().to_glib_none().0,
                parse_name.to_glib_none().0,
            ))
        }
    }

    /// Registers `uri_func` and `parse_name_func` as the [`File`][crate::File] URI and parse name
    /// lookup functions for URIs with a scheme matching `scheme`.
    /// Note that `scheme` is registered only within the running application, as
    /// opposed to desktop-wide as it happens with GVfs backends.
    ///
    /// When a [`File`][crate::File] is requested with an URI containing `scheme` (e.g. through
    /// [`File::for_uri()`][crate::File::for_uri()]), `uri_func` will be called to allow a custom
    /// constructor. The implementation of `uri_func` should not be blocking, and
    /// must not call [`register_uri_scheme()`][Self::register_uri_scheme()] or [`unregister_uri_scheme()`][Self::unregister_uri_scheme()].
    ///
    /// When [`File::for_parse_name()`][crate::File::for_parse_name()] is called with a parse name obtained from such file,
    /// `parse_name_func` will be called to allow the [`File`][crate::File] to be created again. In
    /// that case, it's responsibility of `parse_name_func` to make sure the parse
    /// name matches what the custom [`File`][crate::File] implementation returned when
    /// [`FileExt::parse_name()`][crate::prelude::FileExt::parse_name()] was previously called. The implementation of
    /// `parse_name_func` should not be blocking, and must not call
    /// [`register_uri_scheme()`][Self::register_uri_scheme()] or [`unregister_uri_scheme()`][Self::unregister_uri_scheme()].
    ///
    /// It's an error to call this function twice with the same scheme. To unregister
    /// a custom URI scheme, use [`unregister_uri_scheme()`][Self::unregister_uri_scheme()].
    /// ## `scheme`
    /// an URI scheme, e.g. "http"
    /// ## `uri_func`
    /// a `GVfsFileLookupFunc`
    /// ## `uri_data`
    /// custom data passed to be passed to `uri_func`, or [`None`]
    /// ## `uri_destroy`
    /// function to be called when unregistering the
    ///  URI scheme, or when `self` is disposed, to free the resources used
    ///  by the URI lookup function
    /// ## `parse_name_func`
    /// a `GVfsFileLookupFunc`
    /// ## `parse_name_data`
    /// custom data passed to be passed to
    ///  `parse_name_func`, or [`None`]
    /// ## `parse_name_destroy`
    /// function to be called when unregistering the
    ///  URI scheme, or when `self` is disposed, to free the resources used
    ///  by the parse name lookup function
    ///
    /// # Returns
    ///
    /// [`true`] if `scheme` was successfully registered, or [`false`] if a handler
    ///  for `scheme` already exists.
    #[doc(alias = "g_vfs_register_uri_scheme")]
    fn register_uri_scheme(
        &self,
        scheme: &str,
        uri_func: Option<Box_<dyn Fn(&Vfs, &str) -> File + 'static>>,
        parse_name_func: Option<Box_<dyn Fn(&Vfs, &str) -> File + 'static>>,
    ) -> bool {
        let uri_func_data: Box_<Option<Box_<dyn Fn(&Vfs, &str) -> File + 'static>>> =
            Box_::new(uri_func);
        unsafe extern "C" fn uri_func_func(
            vfs: *mut ffi::GVfs,
            identifier: *const libc::c_char,
            user_data: glib::ffi::gpointer,
        ) -> *mut ffi::GFile {
            let vfs = from_glib_borrow(vfs);
            let identifier: Borrowed<glib::GString> = from_glib_borrow(identifier);
            let callback: &Option<Box_<dyn Fn(&Vfs, &str) -> File + 'static>> =
                &*(user_data as *mut _);
            if let Some(ref callback) = *callback {
                callback(&vfs, identifier.as_str())
            } else {
                panic!("cannot get closure...")
            }
            .to_glib_full()
        }
        let uri_func = if uri_func_data.is_some() {
            Some(uri_func_func as _)
        } else {
            None
        };
        let parse_name_func_data: Box_<Option<Box_<dyn Fn(&Vfs, &str) -> File + 'static>>> =
            Box_::new(parse_name_func);
        unsafe extern "C" fn parse_name_func_func(
            vfs: *mut ffi::GVfs,
            identifier: *const libc::c_char,
            user_data: glib::ffi::gpointer,
        ) -> *mut ffi::GFile {
            let vfs = from_glib_borrow(vfs);
            let identifier: Borrowed<glib::GString> = from_glib_borrow(identifier);
            let callback: &Option<Box_<dyn Fn(&Vfs, &str) -> File + 'static>> =
                &*(user_data as *mut _);
            if let Some(ref callback) = *callback {
                callback(&vfs, identifier.as_str())
            } else {
                panic!("cannot get closure...")
            }
            .to_glib_full()
        }
        let parse_name_func = if parse_name_func_data.is_some() {
            Some(parse_name_func_func as _)
        } else {
            None
        };
        unsafe extern "C" fn uri_destroy_func(data: glib::ffi::gpointer) {
            let _callback: Box_<Option<Box_<dyn Fn(&Vfs, &str) -> File + 'static>>> =
                Box_::from_raw(data as *mut _);
        }
        let destroy_call4 = Some(uri_destroy_func as _);
        unsafe extern "C" fn parse_name_destroy_func(data: glib::ffi::gpointer) {
            let _callback: Box_<Option<Box_<dyn Fn(&Vfs, &str) -> File + 'static>>> =
                Box_::from_raw(data as *mut _);
        }
        let destroy_call7 = Some(parse_name_destroy_func as _);
        let super_callback0: Box_<Option<Box_<dyn Fn(&Vfs, &str) -> File + 'static>>> =
            uri_func_data;
        let super_callback1: Box_<Option<Box_<dyn Fn(&Vfs, &str) -> File + 'static>>> =
            parse_name_func_data;
        unsafe {
            from_glib(ffi::g_vfs_register_uri_scheme(
                self.as_ref().to_glib_none().0,
                scheme.to_glib_none().0,
                uri_func,
                Box_::into_raw(super_callback0) as *mut _,
                destroy_call4,
                parse_name_func,
                Box_::into_raw(super_callback1) as *mut _,
                destroy_call7,
            ))
        }
    }

    /// Unregisters the URI handler for `scheme` previously registered with
    /// [`register_uri_scheme()`][Self::register_uri_scheme()].
    /// ## `scheme`
    /// an URI scheme, e.g. "http"
    ///
    /// # Returns
    ///
    /// [`true`] if `scheme` was successfully unregistered, or [`false`] if a
    ///  handler for `scheme` does not exist.
    #[doc(alias = "g_vfs_unregister_uri_scheme")]
    fn unregister_uri_scheme(&self, scheme: &str) -> bool {
        unsafe {
            from_glib(ffi::g_vfs_unregister_uri_scheme(
                self.as_ref().to_glib_none().0,
                scheme.to_glib_none().0,
            ))
        }
    }
}

impl<O: IsA<Vfs>> VfsExt for O {}

impl fmt::Display for Vfs {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str("Vfs")
    }
}