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

use crate::CheckSyntaxMode;
use crate::CheckSyntaxResult;
use crate::Exception;
use crate::Value;
use crate::VirtualMachine;
use glib::object::Cast;
use glib::object::IsA;
use glib::translate::*;
use glib::StaticType;
use glib::ToValue;
use std::boxed::Box as Box_;
use std::fmt;
use std::ptr;

glib::wrapper! {
    /// JSCContext represents a JavaScript execution context, where all operations
    /// take place and where the values will be associated.
    ///
    /// When a new context is created, a global object is allocated and the built-in JavaScript
    /// objects (Object, Function, String, Array) are populated. You can execute JavaScript in
    /// the context by using [`ContextExt::evaluate()`][crate::prelude::ContextExt::evaluate()] or [`ContextExt::evaluate_with_source_uri()`][crate::prelude::ContextExt::evaluate_with_source_uri()].
    /// It's also possible to register custom objects in the context with `jsc_context_register_class()`.
    ///
    /// # Implements
    ///
    /// [`ContextExt`][trait@crate::prelude::ContextExt]
    #[doc(alias = "JSCContext")]
    pub struct Context(Object<ffi::JSCContext, ffi::JSCContextClass>);

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

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

    /// Create a new [`Context`][crate::Context]. The context is created in a new [`VirtualMachine`][crate::VirtualMachine].
    /// Use [`with_virtual_machine()`][Self::with_virtual_machine()] to create a new [`Context`][crate::Context] in an
    /// existing [`VirtualMachine`][crate::VirtualMachine].
    ///
    /// # Returns
    ///
    /// the newly created [`Context`][crate::Context].
    #[doc(alias = "jsc_context_new")]
    pub fn new() -> Context {
        unsafe { from_glib_full(ffi::jsc_context_new()) }
    }

    /// Create a new [`Context`][crate::Context] in `virtual_machine`.
    /// ## `vm`
    /// a [`VirtualMachine`][crate::VirtualMachine]
    ///
    /// # Returns
    ///
    /// the newly created [`Context`][crate::Context].
    #[doc(alias = "jsc_context_new_with_virtual_machine")]
    #[doc(alias = "new_with_virtual_machine")]
    pub fn with_virtual_machine(vm: &impl IsA<VirtualMachine>) -> Context {
        unsafe {
            from_glib_full(ffi::jsc_context_new_with_virtual_machine(
                vm.as_ref().to_glib_none().0,
            ))
        }
    }

    // rustdoc-stripper-ignore-next
    /// Creates a new builder-pattern struct instance to construct [`Context`] objects.
    ///
    /// This method returns an instance of [`ContextBuilder`](crate::builders::ContextBuilder) which can be used to create [`Context`] objects.
    pub fn builder() -> ContextBuilder {
        ContextBuilder::default()
    }

    /// Get the [`Context`][crate::Context] that is currently executing a function. This should only be
    /// called within a function or method callback, otherwise [`None`] will be returned.
    ///
    /// # Returns
    ///
    /// the [`Context`][crate::Context] that is currently executing.
    #[doc(alias = "jsc_context_get_current")]
    #[doc(alias = "get_current")]
    pub fn current() -> Option<Context> {
        unsafe { from_glib_none(ffi::jsc_context_get_current()) }
    }
}

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

#[derive(Clone, Default)]
// rustdoc-stripper-ignore-next
/// A [builder-pattern] type to construct [`Context`] objects.
///
/// [builder-pattern]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html
#[must_use = "The builder must be built to be used"]
pub struct ContextBuilder {
    virtual_machine: Option<VirtualMachine>,
}

impl ContextBuilder {
    // rustdoc-stripper-ignore-next
    /// Create a new [`ContextBuilder`].
    pub fn new() -> Self {
        Self::default()
    }

    // rustdoc-stripper-ignore-next
    /// Build the [`Context`].
    #[must_use = "Building the object from the builder is usually expensive and is not expected to have side effects"]
    pub fn build(self) -> Context {
        let mut properties: Vec<(&str, &dyn ToValue)> = vec![];
        if let Some(ref virtual_machine) = self.virtual_machine {
            properties.push(("virtual-machine", virtual_machine));
        }
        glib::Object::new::<Context>(&properties)
    }

    /// The [`VirtualMachine`][crate::VirtualMachine] in which the context was created.
    pub fn virtual_machine(mut self, virtual_machine: &impl IsA<VirtualMachine>) -> Self {
        self.virtual_machine = Some(virtual_machine.clone().upcast());
        self
    }
}

/// Trait containing all [`struct@Context`] methods.
///
/// # Implementors
///
/// [`Context`][struct@crate::Context]
pub trait ContextExt: 'static {
    /// Check the given `code` in `self` for syntax errors. The `line_number` is the starting line number in `uri`;
    /// the value is one-based so the first line is 1. `uri` and `line_number` are only used to fill the `exception`.
    /// In case of errors `exception` will be set to a new [`Exception`][crate::Exception] with the details. You can pass [`None`] to
    /// `exception` to ignore the error details.
    /// ## `code`
    /// a JavaScript script to check
    /// ## `length`
    /// length of `code`, or -1 if `code` is a nul-terminated string
    /// ## `mode`
    /// a [`CheckSyntaxMode`][crate::CheckSyntaxMode]
    /// ## `uri`
    /// the source URI
    /// ## `line_number`
    /// the starting line number
    ///
    /// # Returns
    ///
    /// a [`CheckSyntaxResult`][crate::CheckSyntaxResult]
    ///
    /// ## `exception`
    /// return location for a [`Exception`][crate::Exception], or [`None`] to ignore
    #[doc(alias = "jsc_context_check_syntax")]
    fn check_syntax(
        &self,
        code: &str,
        mode: CheckSyntaxMode,
        uri: &str,
        line_number: u32,
    ) -> (CheckSyntaxResult, Exception);

    /// Clear the uncaught exception in `self` if any.
    #[doc(alias = "jsc_context_clear_exception")]
    fn clear_exception(&self);

    /// Evaluate `code` in `self`.
    /// ## `code`
    /// a JavaScript script to evaluate
    /// ## `length`
    /// length of `code`, or -1 if `code` is a nul-terminated string
    ///
    /// # Returns
    ///
    /// a [`Value`][crate::Value] representing the last value generated by the script.
    #[doc(alias = "jsc_context_evaluate")]
    fn evaluate(&self, code: &str) -> Option<Value>;

    //#[doc(alias = "jsc_context_evaluate_in_object")]
    //fn evaluate_in_object(&self, code: &str, object_instance: /*Unimplemented*/Option<Basic: Pointer>, object_class: Option<&Class>, uri: &str, line_number: u32) -> (Value, Value);

    /// Evaluate `code` in `self` using `uri` as the source URI. The `line_number` is the starting line number
    /// in `uri`; the value is one-based so the first line is 1. `uri` and `line_number` will be shown in exceptions and
    /// they don't affect the behavior of the script.
    /// ## `code`
    /// a JavaScript script to evaluate
    /// ## `length`
    /// length of `code`, or -1 if `code` is a nul-terminated string
    /// ## `uri`
    /// the source URI
    /// ## `line_number`
    /// the starting line number
    ///
    /// # Returns
    ///
    /// a [`Value`][crate::Value] representing the last value generated by the script.
    #[doc(alias = "jsc_context_evaluate_with_source_uri")]
    fn evaluate_with_source_uri(&self, code: &str, uri: &str, line_number: u32) -> Option<Value>;

    /// Get the last unhandled exception thrown in `self` by API functions calls.
    ///
    /// # Returns
    ///
    /// a [`Exception`][crate::Exception] or [`None`] if there isn't any
    ///  unhandled exception in the [`Context`][crate::Context].
    #[doc(alias = "jsc_context_get_exception")]
    #[doc(alias = "get_exception")]
    fn exception(&self) -> Option<Exception>;

    /// Get a [`Value`][crate::Value] referencing the `self` global object
    ///
    /// # Returns
    ///
    /// a [`Value`][crate::Value]
    #[doc(alias = "jsc_context_get_global_object")]
    #[doc(alias = "get_global_object")]
    fn global_object(&self) -> Option<Value>;

    /// Get a property of `self` global object with `name`.
    /// ## `name`
    /// the value name
    ///
    /// # Returns
    ///
    /// a [`Value`][crate::Value]
    #[doc(alias = "jsc_context_get_value")]
    #[doc(alias = "get_value")]
    fn value(&self, name: &str) -> Option<Value>;

    /// Get the [`VirtualMachine`][crate::VirtualMachine] where `self` was created.
    ///
    /// # Returns
    ///
    /// the [`VirtualMachine`][crate::VirtualMachine] where the [`Context`][crate::Context] was created.
    #[doc(alias = "jsc_context_get_virtual_machine")]
    #[doc(alias = "get_virtual_machine")]
    fn virtual_machine(&self) -> Option<VirtualMachine>;

    /// Remove the last `JSCExceptionHandler` previously pushed to `self` with
    /// [`push_exception_handler()`][Self::push_exception_handler()].
    #[doc(alias = "jsc_context_pop_exception_handler")]
    fn pop_exception_handler(&self);

    /// Push an exception handler in `self`. Whenever a JavaScript exception happens in
    /// the [`Context`][crate::Context], the given `handler` will be called. The default `JSCExceptionHandler`
    /// simply calls [`throw_exception()`][Self::throw_exception()] to throw the exception to the [`Context`][crate::Context].
    /// If you don't want to catch the exception, but only get notified about it, call
    /// [`throw_exception()`][Self::throw_exception()] in `handler` like the default one does.
    /// The last exception handler pushed is the only one used by the [`Context`][crate::Context], use
    /// [`pop_exception_handler()`][Self::pop_exception_handler()] to remove it and set the previous one. When `handler`
    /// is removed from the context, `destroy_notify` i called with `user_data` as parameter.
    /// ## `handler`
    /// a `JSCExceptionHandler`
    /// ## `destroy_notify`
    /// destroy notifier for `user_data`
    #[doc(alias = "jsc_context_push_exception_handler")]
    fn push_exception_handler<P: Fn(&Context, &Exception) + 'static>(&self, handler: P);

    //#[doc(alias = "jsc_context_register_class")]
    //fn register_class(&self, name: &str, parent_class: Option<&Class>, vtable: /*Ignored*/Option<&mut ClassVTable>) -> Option<Class>;

    /// Set a property of `self` global object with `name` and `value`.
    /// ## `name`
    /// the value name
    /// ## `value`
    /// a [`Value`][crate::Value]
    #[doc(alias = "jsc_context_set_value")]
    fn set_value(&self, name: &str, value: &impl IsA<Value>);

    /// Throw an exception to `self` using the given error message. The created [`Exception`][crate::Exception]
    /// can be retrieved with [`exception()`][Self::exception()].
    /// ## `error_message`
    /// an error message
    #[doc(alias = "jsc_context_throw")]
    fn throw(&self, error_message: &str);

    /// Throw `exception` to `self`.
    /// ## `exception`
    /// a [`Exception`][crate::Exception]
    #[doc(alias = "jsc_context_throw_exception")]
    fn throw_exception(&self, exception: &impl IsA<Exception>);

    //#[doc(alias = "jsc_context_throw_printf")]
    //fn throw_printf(&self, format: &str, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs);

    /// Throw an exception to `self` using the given error name and message. The created [`Exception`][crate::Exception]
    /// can be retrieved with [`exception()`][Self::exception()].
    /// ## `error_name`
    /// the error name
    /// ## `error_message`
    /// an error message
    #[doc(alias = "jsc_context_throw_with_name")]
    fn throw_with_name(&self, error_name: &str, error_message: &str);

    //#[doc(alias = "jsc_context_throw_with_name_printf")]
    //fn throw_with_name_printf(&self, error_name: &str, format: &str, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs);
}

impl<O: IsA<Context>> ContextExt for O {
    fn check_syntax(
        &self,
        code: &str,
        mode: CheckSyntaxMode,
        uri: &str,
        line_number: u32,
    ) -> (CheckSyntaxResult, Exception) {
        let length = code.len() as isize;
        unsafe {
            let mut exception = ptr::null_mut();
            let ret = from_glib(ffi::jsc_context_check_syntax(
                self.as_ref().to_glib_none().0,
                code.to_glib_none().0,
                length,
                mode.into_glib(),
                uri.to_glib_none().0,
                line_number,
                &mut exception,
            ));
            (ret, from_glib_full(exception))
        }
    }

    fn clear_exception(&self) {
        unsafe {
            ffi::jsc_context_clear_exception(self.as_ref().to_glib_none().0);
        }
    }

    fn evaluate(&self, code: &str) -> Option<Value> {
        let length = code.len() as isize;
        unsafe {
            from_glib_full(ffi::jsc_context_evaluate(
                self.as_ref().to_glib_none().0,
                code.to_glib_none().0,
                length,
            ))
        }
    }

    //fn evaluate_in_object(&self, code: &str, object_instance: /*Unimplemented*/Option<Basic: Pointer>, object_class: Option<&Class>, uri: &str, line_number: u32) -> (Value, Value) {
    //    unsafe { TODO: call ffi:jsc_context_evaluate_in_object() }
    //}

    fn evaluate_with_source_uri(&self, code: &str, uri: &str, line_number: u32) -> Option<Value> {
        let length = code.len() as isize;
        unsafe {
            from_glib_full(ffi::jsc_context_evaluate_with_source_uri(
                self.as_ref().to_glib_none().0,
                code.to_glib_none().0,
                length,
                uri.to_glib_none().0,
                line_number,
            ))
        }
    }

    fn exception(&self) -> Option<Exception> {
        unsafe {
            from_glib_none(ffi::jsc_context_get_exception(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn global_object(&self) -> Option<Value> {
        unsafe {
            from_glib_full(ffi::jsc_context_get_global_object(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn value(&self, name: &str) -> Option<Value> {
        unsafe {
            from_glib_full(ffi::jsc_context_get_value(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
            ))
        }
    }

    fn virtual_machine(&self) -> Option<VirtualMachine> {
        unsafe {
            from_glib_none(ffi::jsc_context_get_virtual_machine(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn pop_exception_handler(&self) {
        unsafe {
            ffi::jsc_context_pop_exception_handler(self.as_ref().to_glib_none().0);
        }
    }

    fn push_exception_handler<P: Fn(&Context, &Exception) + 'static>(&self, handler: P) {
        let handler_data: Box_<P> = Box_::new(handler);
        unsafe extern "C" fn handler_func<P: Fn(&Context, &Exception) + 'static>(
            context: *mut ffi::JSCContext,
            exception: *mut ffi::JSCException,
            user_data: glib::ffi::gpointer,
        ) {
            let context = from_glib_borrow(context);
            let exception = from_glib_borrow(exception);
            let callback: &P = &*(user_data as *mut _);
            (*callback)(&context, &exception);
        }
        let handler = Some(handler_func::<P> as _);
        unsafe extern "C" fn destroy_notify_func<P: Fn(&Context, &Exception) + 'static>(
            data: glib::ffi::gpointer,
        ) {
            let _callback: Box_<P> = Box_::from_raw(data as *mut _);
        }
        let destroy_call3 = Some(destroy_notify_func::<P> as _);
        let super_callback0: Box_<P> = handler_data;
        unsafe {
            ffi::jsc_context_push_exception_handler(
                self.as_ref().to_glib_none().0,
                handler,
                Box_::into_raw(super_callback0) as *mut _,
                destroy_call3,
            );
        }
    }

    //fn register_class(&self, name: &str, parent_class: Option<&Class>, vtable: /*Ignored*/Option<&mut ClassVTable>) -> Option<Class> {
    //    unsafe { TODO: call ffi:jsc_context_register_class() }
    //}

    fn set_value(&self, name: &str, value: &impl IsA<Value>) {
        unsafe {
            ffi::jsc_context_set_value(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
                value.as_ref().to_glib_none().0,
            );
        }
    }

    fn throw(&self, error_message: &str) {
        unsafe {
            ffi::jsc_context_throw(
                self.as_ref().to_glib_none().0,
                error_message.to_glib_none().0,
            );
        }
    }

    fn throw_exception(&self, exception: &impl IsA<Exception>) {
        unsafe {
            ffi::jsc_context_throw_exception(
                self.as_ref().to_glib_none().0,
                exception.as_ref().to_glib_none().0,
            );
        }
    }

    //fn throw_printf(&self, format: &str, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) {
    //    unsafe { TODO: call ffi:jsc_context_throw_printf() }
    //}

    fn throw_with_name(&self, error_name: &str, error_message: &str) {
        unsafe {
            ffi::jsc_context_throw_with_name(
                self.as_ref().to_glib_none().0,
                error_name.to_glib_none().0,
                error_message.to_glib_none().0,
            );
        }
    }

    //fn throw_with_name_printf(&self, error_name: &str, format: &str, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) {
    //    unsafe { TODO: call ffi:jsc_context_throw_with_name_printf() }
    //}
}

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