// Take a look at the license at the top of the repository in the LICENSE file.

use glib::{prelude::*, translate::*};
use libc::uintptr_t;

use crate::{GLContext, GLDisplay, GLPlatform, GLAPI};

impl GLContext {
    /// Wraps an existing OpenGL context into a [`GLContext`][crate::GLContext].
    ///
    /// Note: The caller is responsible for ensuring that the OpenGL context
    /// represented by `handle` stays alive while the returned [`GLContext`][crate::GLContext] is
    /// active.
    ///
    /// `context_type` must not be `GST_GL_PLATFORM_NONE` or `GST_GL_PLATFORM_ANY`
    ///
    /// `available_apis` must not be `GST_GL_API_NONE` or `GST_GL_API_ANY`
    /// ## `display`
    /// a [`GLDisplay`][crate::GLDisplay]
    /// ## `handle`
    /// the OpenGL context to wrap
    /// ## `context_type`
    /// a [`GLPlatform`][crate::GLPlatform] specifying the type of context in `handle`
    /// ## `available_apis`
    /// a [`GLAPI`][crate::GLAPI] containing the available OpenGL apis in `handle`
    ///
    /// # Returns
    ///
    /// a [`GLContext`][crate::GLContext] wrapping `handle`
    pub unsafe fn new_wrapped<T: IsA<GLDisplay>>(
        display: &T,
        handle: uintptr_t,
        context_type: GLPlatform,
        available_apis: GLAPI,
    ) -> Option<Self> {
        from_glib_full(ffi::gst_gl_context_new_wrapped(
            display.as_ref().to_glib_none().0,
            handle,
            context_type.into_glib(),
            available_apis.into_glib(),
        ))
    }

    /// ## `context_type`
    /// a [`GLPlatform`][crate::GLPlatform] specifying the type of context to retrieve
    ///
    /// # Returns
    ///
    /// The OpenGL context handle current in the calling thread or [`None`]
    #[doc(alias = "get_current_gl_context")]
    #[doc(alias = "gst_gl_context_get_current_gl_context")]
    pub fn current_gl_context(context_type: GLPlatform) -> uintptr_t {
        skip_assert_initialized!();
        unsafe { ffi::gst_gl_context_get_current_gl_context(context_type.into_glib()) as uintptr_t }
    }

    /// Attempts to use the `context_type` specific GetProcAddress implementations
    /// to retrieve `name`.
    ///
    /// See also [`GLContextExtManual::proc_address()`][crate::prelude::GLContextExtManual::proc_address()].
    /// ## `context_type`
    /// a [`GLPlatform`][crate::GLPlatform]
    /// ## `gl_api`
    /// a [`GLAPI`][crate::GLAPI]
    /// ## `name`
    /// the name of the function to retrieve
    ///
    /// # Returns
    ///
    /// a function pointer for `name`, or [`None`]
    #[doc(alias = "get_proc_address_with_platform")]
    #[doc(alias = "gst_gl_context_get_proc_address_with_platform")]
    pub fn proc_address_with_platform(
        context_type: GLPlatform,
        gl_api: GLAPI,
        name: &str,
    ) -> uintptr_t {
        skip_assert_initialized!();
        unsafe {
            ffi::gst_gl_context_get_proc_address_with_platform(
                context_type.into_glib(),
                gl_api.into_glib(),
                name.to_glib_none().0,
            ) as uintptr_t
        }
    }
}

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

pub trait GLContextExtManual: sealed::Sealed + IsA<GLContext> + 'static {
    /// Gets the backing OpenGL context used by `self`.
    ///
    /// # Returns
    ///
    /// The platform specific backing OpenGL context
    #[doc(alias = "get_gl_context")]
    #[doc(alias = "gst_gl_context_get_gl_context")]
    fn gl_context(&self) -> uintptr_t {
        unsafe { ffi::gst_gl_context_get_gl_context(self.as_ref().to_glib_none().0) as uintptr_t }
    }

    /// Get a function pointer to a specified opengl function, `name`. If the the
    /// specific function does not exist, NULL is returned instead.
    ///
    /// Platform specific functions (names starting 'egl', 'glX', 'wgl', etc) can also
    /// be retrieved using this method.
    ///
    /// Note: This function may return valid function pointers that may not be valid
    /// to call in `self`. The caller is responsible for ensuring that the
    /// returned function is a valid function to call in `self` by either checking
    /// the OpenGL API and version or for an appropriate OpenGL extension.
    ///
    /// Note: On success, you need to cast the returned function pointer to the
    /// correct type to be able to call it correctly. On 32-bit Windows, this will
    /// include the `GSTGLAPI` identifier to use the correct calling convention.
    /// e.g.
    ///
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    /// void (GSTGLAPI *PFN_glGetIntegerv) (GLenum name, GLint * ret)
    /// ```
    /// ## `name`
    /// an opengl function name
    ///
    /// # Returns
    ///
    /// a function pointer or [`None`]
    #[doc(alias = "get_proc_address")]
    #[doc(alias = "gst_gl_context_get_proc_address")]
    fn proc_address(&self, name: &str) -> uintptr_t {
        unsafe {
            ffi::gst_gl_context_get_proc_address(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
            ) as uintptr_t
        }
    }

    /// Execute `func` in the OpenGL thread of `self` with `data`
    ///
    /// MT-safe
    /// ## `func`
    /// a `GstGLContextThreadFunc`
    #[doc(alias = "gst_gl_context_thread_add")]
    fn thread_add<F: FnOnce(&Self) + Send>(&self, func: F) {
        let mut func = std::mem::ManuallyDrop::new(func);
        let user_data: *mut F = &mut *func;

        unsafe extern "C" fn trampoline<O: IsA<GLContext>, F: FnOnce(&O) + Send>(
            context: *mut ffi::GstGLContext,
            data: glib::ffi::gpointer,
        ) {
            let func = std::ptr::read(data as *mut F);
            let context = GLContext::from_glib_borrow(context);
            func(context.unsafe_cast_ref())
        }

        unsafe {
            ffi::gst_gl_context_thread_add(
                self.as_ref().to_glib_none().0,
                Some(trampoline::<Self, F>),
                user_data as glib::ffi::gpointer,
            );
        }
    }
}

impl<O: IsA<GLContext>> GLContextExtManual for O {}