use std::any::TypeId;
use std::cell::RefCell;
use std::collections::HashMap;
use std::marker::PhantomData;
#[cfg(rlua_lua54)]
use std::os::raw::c_uint;
use std::os::raw::{c_int, c_void};
use std::ptr;
use std::rc::Rc;
use std::sync::{Arc, Mutex};

use bitflags::bitflags;
use libc;

use crate::context::Context;
use crate::error::Result;
use crate::ffi;
use crate::hook::{hook_proc, Debug, HookTriggers};
use crate::markers::NoRefUnwindSafe;
use crate::types::Callback;
use crate::util::{
    assert_stack, dostring, init_error_registry, protect_lua_closure, push_globaltable, rawlen,
    requiref, safe_pcall, safe_xpcall, userdata_destructor,
};

bitflags! {
    /// Flags describing the set of lua modules to load.
    pub struct StdLib: u32 {
        const BASE = 0x1;
        const COROUTINE = 0x2;
        const TABLE = 0x4;
        const IO = 0x8;
        const OS = 0x10;
        const STRING = 0x20;
        const UTF8 = 0x40;
        const MATH = 0x80;
        const PACKAGE = 0x100;
        const DEBUG = 0x200;

        const ALL = StdLib::BASE.bits
            | StdLib::COROUTINE.bits
            | StdLib::TABLE.bits
            | StdLib::IO.bits
            | StdLib::OS.bits
            | StdLib::STRING.bits
            | StdLib::UTF8.bits
            | StdLib::MATH.bits
            | StdLib::PACKAGE.bits
            | StdLib::DEBUG.bits;

        const ALL_NO_DEBUG = StdLib::BASE.bits
            | StdLib::COROUTINE.bits
            | StdLib::TABLE.bits
            | StdLib::IO.bits
            | StdLib::OS.bits
            | StdLib::STRING.bits
            | StdLib::UTF8.bits
            | StdLib::MATH.bits
            | StdLib::PACKAGE.bits;
    }
}

bitflags! {
    /// Flags describing the set of lua modules to load.
    pub struct InitFlags: u32 {
        const PCALL_WRAPPERS = 0x1;
        const LOAD_WRAPPERS = 0x2;
        const REMOVE_LOADLIB = 0x4;

        const DEFAULT = InitFlags::PCALL_WRAPPERS.bits |
                        InitFlags::LOAD_WRAPPERS.bits |
                        InitFlags::REMOVE_LOADLIB.bits;
        const NONE = 0;
    }
}

#[cfg(rlua_lua54)]
// at 812, tests pass
// at 813, tests fail
// at 700, it should be somewhat safe
// TODO: move this somewhere nicer
// TODO: make this configurable?
const SAFE_CSTACK_SIZE: c_uint = 700;

/// Top level Lua struct which holds the Lua state itself.
#[derive(Debug)]
pub struct Lua {
    main_state: *mut ffi::lua_State,
    _no_ref_unwind_safe: NoRefUnwindSafe,
}

unsafe impl Send for Lua {}

impl Drop for Lua {
    fn drop(&mut self) {
        unsafe {
            let extra = extra_data(self.main_state);
            rlua_debug_assert!(
                ffi::lua_gettop((*extra).ref_thread) == (*extra).ref_stack_max
                    && (*extra).ref_stack_max as usize == (*extra).ref_free.len(),
                "reference leak detected"
            );
            *rlua_expect!((*extra).registry_unref_list.lock(), "unref list poisoned") = None;
            ffi::lua_close(self.main_state);
            Box::from_raw(extra);
        }
    }
}

impl Lua {
    /// Creates a new Lua state and loads standard library without the `debug` library.
    pub fn new() -> Lua {
        unsafe { create_lua(StdLib::ALL_NO_DEBUG, InitFlags::DEFAULT) }
    }

    /// Creates a new Lua state and loads the standard library including the `debug` library.
    ///
    /// The debug library is very unsound, it can be used to break the safety guarantees of rlua.
    pub unsafe fn new_with_debug() -> Lua {
        create_lua(StdLib::ALL, InitFlags::DEFAULT)
    }

    /// Creates a new Lua state and loads a subset of the standard libraries.
    ///
    /// Use the [`StdLib`] flags to specifiy the libraries you want to load.
    ///
    /// Note that the `debug` library can't be loaded using this function as it can be used to break
    /// the safety guarantees of rlua.  If you really want to load it, use the sister function
    /// [`Lua::unsafe_new_with`].
    ///
    /// # Panics
    ///
    /// Panics if `lua_mod` contains `StdLib::DEBUG`
    pub fn new_with(lua_mod: StdLib) -> Lua {
        assert!(
            !lua_mod.contains(StdLib::DEBUG),
            "The lua debug module can't be loaded using `new_with`. Use `unsafe_new_with` instead."
        );

        unsafe { create_lua(lua_mod, InitFlags::DEFAULT) }
    }

    /// Creates a new Lua state and loads a subset of the standard libraries.
    ///
    /// Use the [`StdLib`] flags to specifiy the libraries you want to load.
    ///
    /// This function is unsafe because it can be used to load the `debug` library which can be used
    /// to break the safety guarantees provided by rlua.
    pub unsafe fn unsafe_new_with(lua_mod: StdLib) -> Lua {
        create_lua(lua_mod, InitFlags::DEFAULT)
    }

    /// Creates a new Lua state with a subset of the standard libraries and
    /// modified initialization.
    ///
    /// Use the [`StdLib`] flags to specifiy the libraries you want to load.
    /// Use the [`InitFlags`] to specify non-default Lua configuration.
    ///
    /// `unsafe_new_with_flags(mods, InitFlags::DEFAULT)` is equivalent to
    /// `unsafe_new_with(mods)`.
    ///
    /// This function is unsafe because it can be used to load the `debug` library which can be used
    /// to break the safety guarantees provided by rlua, or to disable some of the safety features
    /// which rlua provides by default.
    pub unsafe fn unsafe_new_with_flags(lua_mod: StdLib, init_flags: InitFlags) -> Lua {
        create_lua(lua_mod, init_flags)
    }

    /// Loads the specified set of safe standard libraries into an existing Lua state.
    ///
    /// Use the [`StdLib`] flags to specifiy the libraries you want to load.
    ///
    /// Note that the `debug` library can't be loaded using this function as it can be used to break
    /// the safety guarantees of rlua.  If you really want to load it, use the sister function
    /// [`Lua::unsafe_load_from_std_lib`].
    ///
    /// # Panics
    ///
    /// Panics if `lua_mod` contains `StdLib::DEBUG`
    pub fn load_from_std_lib(&self, lua_mod: StdLib) -> Result<()> {
        assert!(
            !lua_mod.contains(StdLib::DEBUG),
            "The lua debug module can't be loaded using `load_from_std_lib`. Use `unsafe_load_from_std_lib` instead."
        );

        unsafe {
            protect_lua_closure(self.main_state, 0, 0, |state| {
                load_from_std_lib(state, lua_mod);
            })
        }
    }

    /// Loads the specified set of standard libraries into an existing Lua state.
    ///
    /// Use the [`StdLib`] flags to specifiy the libraries you want to load.
    ///
    /// This function is unsafe because it can be used to load the `debug` library which can be used
    /// to break the safety guarantees provided by rlua.
    pub unsafe fn unsafe_load_from_std_lib(&self, lua_mod: StdLib) -> Result<()> {
        protect_lua_closure(self.main_state, 0, 0, |state| {
            load_from_std_lib(state, lua_mod);
        })
    }

    /// The main entry point of the rlua API.
    ///
    /// In order to create Lua values, load and execute Lua code, or otherwise interact with the Lua
    /// state in any way, you must first call `Lua::context` and then call methods on the provided
    /// [`Context`] parameter.
    ///
    /// rlua uses reference types like `String` and `Table` which reference shared data in the Lua
    /// state.  These are special reference counted types that contain pointers to the main Lua
    /// state via the [`Context`] type, and there is a `'lua` lifetime associated with these.
    ///
    /// This `'lua` lifetime is somewhat special.  It is what is sometimes called a "generative"
    /// lifetime or a "branding" lifetime, which is invariant, and unique for each call to
    /// `Lua::context`.
    ///
    /// The reason this entry point must be a callback is so that this unique lifetime can be
    /// generated as part of the callback's parameters.  Even though this callback API is somewhat
    /// inconvenient, it has several advantages:
    ///
    /// - Inside calls to `Lua::context`, we know that all instances of the 'lua lifetime are the
    ///   same unique lifetime.  Thus, it is impossible for the user to accidentally mix handle
    ///   types between different instances of `Lua`.
    /// - Because we know at compile time that handles cannot be mixed from different instances of
    ///   `Lua`, we do not need to do runtime checks to make sure that handles are from the same
    ///   state.
    /// - Handle types cannot escape the context call and the `'lua` context lifetime is in general
    ///   very limited, preventing it from being stored in unexpected places.  This is a benefit as
    ///   it helps ensure the soundness of the API.
    ///
    /// It is not possible to return types with this `'lua` context lifetime from the given
    /// callback, or store them outside of the callback in any way.  There is an escape hatch here,
    /// though: if you need to keep references to internal Lua values long-term, you can use the Lua
    /// registry via [`Context::set_named_registry_value`] and [`Context::create_registry_value`].
    ///
    /// # Examples
    ///
    /// ```
    /// # use rlua::{Lua, Result};
    /// # fn main() -> Result<()> {
    /// let lua = Lua::new();
    /// lua.context(|lua_context| {
    ///    lua_context.load(r#"
    ///        print("hello world!")
    ///    "#).exec()
    /// })?;
    /// # Ok(())
    /// # }
    /// ```
    ///
    /// [`Context`]: struct.Context.html
    /// [`Context::set_named_registry_value`]: struct.Context.html#method.set_named_registry_value
    /// [`Context::create_registry_value`]: struct.Context.html#method.create_registry_value
    pub fn context<F, R>(&self, f: F) -> R
    where
        F: FnOnce(Context) -> R,
    {
        f(unsafe { Context::new(self.main_state) })
    }

    /// Sets a 'hook' function that will periodically be called as Lua code executes.
    ///
    /// When exactly the hook function is called depends on the contents of the `triggers`
    /// parameter, see [`HookTriggers`] for more details.
    ///
    /// The provided hook function can error, and this error will be propagated through the Lua code
    /// that was executing at the time the hook was triggered.  This can be used to implement a
    /// limited form of execution limits by setting [`HookTriggers.every_nth_instruction`] and
    /// erroring once an instruction limit has been reached.
    ///
    /// # Example
    ///
    /// Shows each line number of code being executed by the Lua interpreter.
    ///
    /// ```
    /// # use rlua::{Lua, HookTriggers, Result};
    /// # fn main() -> Result<()> {
    /// let lua = Lua::new();
    /// lua.set_hook(HookTriggers {
    ///     every_line: true, ..Default::default()
    /// }, |_lua_context, debug| {
    ///     println!("line {}", debug.curr_line());
    ///     Ok(())
    /// });
    /// lua.context(|lua_context| {
    ///     lua_context.load(r#"
    ///         local x = 2 + 3
    ///         local y = x * 63
    ///         local z = string.len(x..", "..y)
    ///     "#).exec()
    /// })?;
    /// # Ok(())
    /// # }
    /// ```
    ///
    /// [`HookTriggers`]: struct.HookTriggers.html
    /// [`HookTriggers.every_nth_instruction`]: struct.HookTriggers.html#field.every_nth_instruction
    pub fn set_hook<F>(&self, triggers: HookTriggers, callback: F)
    where
        F: 'static + Send + FnMut(Context, Debug) -> Result<()>,
    {
        unsafe {
            (*extra_data(self.main_state)).hook_callback = Some(Rc::new(RefCell::new(callback)));
            ffi::lua_sethook(
                self.main_state,
                Some(hook_proc),
                triggers.mask(),
                triggers.count(),
            );
        }
    }

    /// Remove any hook previously set by `set_hook`. This function has no effect if a hook was not
    /// previously set.
    pub fn remove_hook(&self) {
        unsafe {
            (*extra_data(self.main_state)).hook_callback = None;
            ffi::lua_sethook(self.main_state, None, 0, 0);
        }
    }

    /// Returns the memory currently used inside this Lua state.
    pub fn used_memory(&self) -> usize {
        unsafe { (*extra_data(self.main_state)).used_memory }
    }

    /// Sets a memory limit on this Lua state.  Once an allocation occurs that would pass this
    /// memory limit, a `Error::MemoryError` is generated instead.
    pub fn set_memory_limit(&self, memory_limit: Option<usize>) {
        unsafe {
            (*extra_data(self.main_state)).memory_limit = memory_limit;
        }
    }

    #[cfg(any(rlua_lua53, rlua_lua54))]
    /// Returns true if the garbage collector is currently running automatically.
    pub fn gc_is_running(&self) -> bool {
        unsafe { ffi::lua_gc(self.main_state, ffi::LUA_GCISRUNNING, 0) != 0 }
    }

    /// Stop the Lua GC from running
    pub fn gc_stop(&self) {
        unsafe {
            ffi::lua_gc(self.main_state, ffi::LUA_GCSTOP, 0);
        }
    }

    /// Restarts the Lua GC if it is not running
    pub fn gc_restart(&self) {
        unsafe {
            ffi::lua_gc(self.main_state, ffi::LUA_GCRESTART, 0);
        }
    }

    /// Perform a full garbage-collection cycle.
    ///
    /// It may be necessary to call this function twice to collect all currently unreachable
    /// objects.  Once to finish the current gc cycle, and once to start and finish the next cycle.
    pub fn gc_collect(&self) -> Result<()> {
        unsafe {
            protect_lua_closure(self.main_state, 0, 0, |state| {
                ffi::lua_gc(state, ffi::LUA_GCCOLLECT, 0);
            })
        }
    }

    /// Steps the garbage collector one indivisible step.
    ///
    /// Returns true if this has finished a collection cycle.
    pub fn gc_step(&self) -> Result<bool> {
        self.gc_step_kbytes(0)
    }

    /// Steps the garbage collector as though memory had been allocated.
    ///
    /// if `kbytes` is 0, then this is the same as calling `gc_step`.  Returns true if this step has
    /// finished a collection cycle.
    pub fn gc_step_kbytes(&self, kbytes: c_int) -> Result<bool> {
        unsafe {
            protect_lua_closure(self.main_state, 0, 0, |state| {
                ffi::lua_gc(state, ffi::LUA_GCSTEP, kbytes) != 0
            })
        }
    }

    #[cfg(rlua_lua54)]
    /// Sets the garbage collector to incremental mode.
    ///
    /// Returns the previous mode (`LUA_GCGEN` or `LUA_GCINC`).  More information can be found in the
    /// [Lua 5.4 documentation][lua_doc].
    ///
    /// [lua_doc]: https://www.lua.org/manual/5.4/manual.html#2.5
    pub fn gc_set_inc(&self, pause: c_int, step_multiplier: c_int, step_size: c_int) -> c_int {
        unsafe {
            ffi::lua_gc(
                self.main_state,
                ffi::LUA_GCINC,
                pause,
                step_multiplier,
                step_size,
            )
        }
    }

    #[cfg(rlua_lua54)]
    /// Sets the garbage collector to generational mode.
    ///
    /// Returns the previous mode (`LUA_GCGEN` or `LUA_GCINC`).  More information can be found in the
    /// [Lua 5.4 documentation][lua_doc].
    ///
    /// [lua_doc]: https://www.lua.org/manual/5.4/manual.html#2.5
    pub fn gc_set_gen(&self, minor_multiplier: c_int, major_multiplier: c_int) -> c_int {
        unsafe {
            ffi::lua_gc(
                self.main_state,
                ffi::LUA_GCGEN,
                minor_multiplier,
                major_multiplier,
            )
        }
    }

    /// Sets the 'pause' value of the incremental collector.
    ///
    /// Returns the previous value of 'pause'.  More information can be found in the [Lua 5.4
    /// documentation][lua_doc].
    ///
    /// [lua_doc]: https://www.lua.org/manual/5.4/manual.html#2.5
    #[cfg_attr(rlua_lua54, deprecated(note = "please use `gc_set_inc` instead"))]
    #[allow(deprecated)]
    pub fn gc_set_pause(&self, pause: c_int) -> c_int {
        unsafe { ffi::lua_gc(self.main_state, ffi::LUA_GCSETPAUSE, pause) }
    }

    /// Sets the 'step multiplier' value of the incremental collector.
    ///
    /// Returns the previous value of the 'step multiplier'.  More information can be found in the
    /// [Lua 5.4 documentation][lua_doc].
    ///
    /// [lua_doc]: https://www.lua.org/manual/5.4/manual.html#2.5
    #[cfg_attr(rlua_lua54, deprecated(note = "please use `gc_set_inc` instead"))]
    #[allow(deprecated)]
    pub fn gc_set_step_multiplier(&self, step_multiplier: c_int) -> c_int {
        unsafe { ffi::lua_gc(self.main_state, ffi::LUA_GCSETSTEPMUL, step_multiplier) }
    }
}

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

// Data associated with the main lua_State via lua_getextraspace.
pub(crate) struct ExtraData {
    pub registered_userdata: HashMap<TypeId, c_int>,
    pub registry_unref_list: Arc<Mutex<Option<Vec<c_int>>>>,

    pub ref_thread: *mut ffi::lua_State,
    pub ref_stack_size: c_int,
    pub ref_stack_max: c_int,
    pub ref_free: Vec<c_int>,

    used_memory: usize,
    memory_limit: Option<usize>,

    pub hook_callback: Option<Rc<RefCell<dyn FnMut(Context, Debug) -> Result<()>>>>,
}

// Return the extra data pointer passed to `lua_newstate()`.  `state` must
// be the main state, not a substate.
pub(crate) unsafe fn extra_data(state: *mut ffi::lua_State) -> *mut ExtraData {
    #[cfg(any(rlua_lua53, rlua_lua54))]
    return *(ffi::lua_getextraspace(state) as *mut *mut ExtraData);
    #[cfg(rlua_lua51)]
    {
        let mut extra: *mut c_void = ptr::null_mut();
        let _ = ffi::lua_getallocf(state, &mut extra);
        return extra as *mut ExtraData;
    }
}

unsafe fn create_lua(lua_mod_to_load: StdLib, init_flags: InitFlags) -> Lua {
    unsafe extern "C" fn allocator(
        extra_data: *mut c_void,
        ptr: *mut c_void,
        osize: usize,
        nsize: usize,
    ) -> *mut c_void {
        let extra_data = extra_data as *mut ExtraData;

        // If the `ptr` argument is null, osize instead encodes the allocated object type, which
        // we currently ignore.
        let new_used_memory = if ptr.is_null() {
            (*extra_data).used_memory + nsize
        } else if nsize >= osize {
            (*extra_data).used_memory + (nsize - osize)
        } else {
            (*extra_data).used_memory - (osize - nsize)
        };

        if new_used_memory > (*extra_data).used_memory {
            // We only check memory limits when memory is allocated, not freed
            if let Some(memory_limit) = (*extra_data).memory_limit {
                if new_used_memory > memory_limit {
                    return ptr::null_mut();
                }
            }
        }

        if nsize == 0 {
            (*extra_data).used_memory = new_used_memory;
            libc::free(ptr as *mut libc::c_void);
            ptr::null_mut()
        } else {
            let p = libc::realloc(ptr as *mut libc::c_void, nsize) as *mut c_void;
            if !p.is_null() {
                // Only commit the new used memory if the allocation was successful.  Probably in
                // reality, libc::realloc will never fail.
                (*extra_data).used_memory = new_used_memory;
            }
            p
        }
    }

    let mut extra = Box::new(ExtraData {
        registered_userdata: HashMap::new(),
        registry_unref_list: Arc::new(Mutex::new(Some(Vec::new()))),
        ref_thread: ptr::null_mut(),
        // We need 1 extra stack space to move values in and out of the ref stack.
        ref_stack_size: ffi::LUA_MINSTACK - 1,
        ref_stack_max: 0,
        ref_free: Vec::new(),
        used_memory: 0,
        memory_limit: None,
        hook_callback: None,
    });

    let state = ffi::lua_newstate(
        Some(allocator),
        &mut *extra as *mut ExtraData as *mut c_void,
    );

    #[cfg(rlua_lua54)]
    ffi::lua_setcstacklimit(state, SAFE_CSTACK_SIZE);

    extra.ref_thread = rlua_expect!(
        protect_lua_closure(state, 0, 0, |state| {
            load_from_std_lib(state, lua_mod_to_load);

            init_error_registry(state, init_flags.contains(InitFlags::PCALL_WRAPPERS));

            // Create the function metatable

            ffi::lua_pushlightuserdata(
                state,
                &FUNCTION_METATABLE_REGISTRY_KEY as *const u8 as *mut c_void,
            );

            ffi::lua_newtable(state);

            ffi::lua_pushstring(state, cstr!("__gc"));
            ffi::lua_pushcfunction(state, Some(userdata_destructor::<Callback>));
            ffi::lua_rawset(state, -3);

            ffi::lua_pushstring(state, cstr!("__metatable"));
            ffi::lua_pushboolean(state, 0);
            ffi::lua_rawset(state, -3);

            ffi::lua_rawset(state, ffi::LUA_REGISTRYINDEX);

            // Override pcall and xpcall with versions that cannot be used to catch rust panics.
            if init_flags.contains(InitFlags::PCALL_WRAPPERS) {
                push_globaltable(state);

                ffi::lua_pushstring(state, cstr!("pcall"));
                ffi::lua_pushcfunction(state, Some(safe_pcall));
                ffi::lua_rawset(state, -3);

                ffi::lua_pushstring(state, cstr!("xpcall"));
                ffi::lua_pushcfunction(state, Some(safe_xpcall));
                ffi::lua_rawset(state, -3);

                ffi::lua_pop(state, 1);
            }

            // Override dofile, load, and loadfile with versions that won't load
            // binary files.
            if init_flags.contains(InitFlags::LOAD_WRAPPERS) {
                // These are easier to override in Lua.
                #[cfg(any(rlua_lua53, rlua_lua54))]
                let wrapload = r#"
                    do
                        -- load(chunk [, chunkname [, mode [, env]]])
                        local real_load = load
                        load = function(...)
                            local args = table.pack(...)
                            args[3] = "t"
                            if args.n < 3 then args.n = 3 end
                            return real_load(table.unpack(args))
                        end

                        -- loadfile ([filename [, mode [, env]]])
                        local real_loadfile = loadfile
                        local real_error = error
                        loadfile = function(...)
                            local args = table.pack(...)
                            args[2] = "t"
                            if args.n < 2 then args.n = 2 end
                            return real_loadfile(table.unpack(args))
                        end

                        -- dofile([filename])
                        local real_dofile = dofile
                        dofile = function(filename)
                            -- Note: this is the wrapped loadfile above
                            local chunk = loadfile(filename)
                            if chunk then
                                return chunk()
                            else
                                real_error("rlua dofile: attempt to load bytecode")
                            end
                        end
                    end
                "#;
                #[cfg(rlua_lua51)]
                let wrapload = r#"
                    do
                        -- load(chunk [, chunkname])
                        local real_load = load
                        -- save type() in case user code replaces it
                        local real_type = type
                        local real_error = error
                        load = function(func, chunkname) 
                            local first_chunk = true
                            local wrap_func = function()
                                if not first_chunk then
                                    return func()
                                else
                                    local data = func()
                                    if data == nil then return nil end
                                    assert(real_type(data) == "string")
                                    if data:len() > 0 then
                                        if data:byte(1) == 27 then
                                            real_error("rlua load: loading binary chunks is not allowed")
                                        end
                                        first_chunk = false
                                    end
                                    return data
                                end
                            end
                            return real_load(wrap_func, chunkname)
                        end

                        -- loadstring(string [, chunkname])
                        local real_loadstring = loadstring
                        loadstring = function(s, chunkname)
                            if type(s) ~= "string" then
                                real_error("rlua loadstring: string expected.")
                            elseif s:byte(1) == 27 then
                                -- This is a binary chunk, so disallow
                                return nil, "rlua loadstring: loading binary chunks is not allowed"
                            else
                                return real_loadstring(s, chunkname)
                            end
                        end

                        -- loadfile ([filename])
                        local real_loadfile = loadfile
                        local real_io_open = io.open
                        loadfile = function(filename)
                            local f, err = real_io_open(filename, "rb")
                            if not f then
                                return nil, err
                            end
                            local first_chunk = true
                            local func = function()
                                return f:read(4096)
                            end
                            -- Note: the safe load from above.
                            return load(func, filename)
                        end

                        -- dofile([filename])
                        local real_dofile = dofile
                        dofile = function(filename)
                            -- Note: this is the wrapped loadfile above
                            local chunk = loadfile(filename)
                            if chunk then
                                return chunk()
                            else
                                real_error("rlua dofile: attempt to load bytecode")
                            end
                        end
                    end
                "#;

                let result = dostring(state, wrapload);
                if result != 0 {
                    use std::ffi::CStr;
                    let errmsg = ffi::lua_tostring(state, -1);
                    eprintln!(
                        "Internal error running setup code: {:?}",
                        CStr::from_ptr(errmsg)
                    );
                }
                assert_eq!(result, 0);
            }

            if init_flags.contains(InitFlags::REMOVE_LOADLIB) {
                ffi::lua_getglobal(state, cstr!("package"));
                let t = ffi::lua_type(state, -1);
                if t == ffi::LUA_TTABLE {
                    // Package is loaded.  Remove loadlib.
                    ffi::lua_pushnil(state);
                    ffi::lua_setfield(state, -2, cstr!("loadlib"));

                    #[cfg(rlua_lua51)]
                    let searchers_name = cstr!("loaders");
                    #[cfg(any(rlua_lua53, rlua_lua54))]
                    let searchers_name = cstr!("searchers");

                    ffi::lua_getfield(state, -1, searchers_name);
                    debug_assert_eq!(ffi::lua_type(state, -1), ffi::LUA_TTABLE);
                    debug_assert_eq!(rawlen(state, -1), 4);
                    // Remove the searchers/loaders which will load C libraries.
                    ffi::lua_pushnil(state);
                    ffi::lua_rawseti(state, -2, 4);
                    ffi::lua_pushnil(state);
                    ffi::lua_rawseti(state, -2, 3);

                    ffi::lua_pop(state, 1);
                } else {
                    // Assume it's not present otherwise.
                    assert_eq!(t, ffi::LUA_TNIL);
                }
                // Pop the package (or nil) off the stack.
                ffi::lua_pop(state, 1);
            }

            // Create ref stack thread and place it in the registry to prevent it from being garbage
            // collected.

            let ref_thread = ffi::lua_newthread(state);
            ffi::luaL_ref(state, ffi::LUA_REGISTRYINDEX);
            ref_thread
        }),
        "Error during Lua construction",
    );

    rlua_debug_assert!(ffi::lua_gettop(state) == 0, "stack leak during creation");
    assert_stack(state, ffi::LUA_MINSTACK as i32);

    #[cfg(any(rlua_lua53, rlua_lua54))]
    {
        // Place pointer to ExtraData in the lua_State "extra space"
        *(ffi::lua_getextraspace(state) as *mut *mut ExtraData) = Box::into_raw(extra);
    }
    #[cfg(rlua_lua51)]
    // Prevent extra from being deallocated
    let _ = Box::into_raw(extra);

    Lua {
        main_state: state,
        _no_ref_unwind_safe: PhantomData,
    }
}

unsafe fn load_from_std_lib(state: *mut ffi::lua_State, lua_mod: StdLib) {
    if lua_mod.contains(StdLib::BASE) {
        requiref(state, cstr!("_G"), Some(ffi::luaopen_base), 1);
    }
    #[cfg(any(rlua_lua53, rlua_lua54))]
    if lua_mod.contains(StdLib::COROUTINE) {
        requiref(state, cstr!("coroutine"), Some(ffi::luaopen_coroutine), 1);
    }
    if lua_mod.contains(StdLib::TABLE) {
        requiref(state, cstr!("table"), Some(ffi::luaopen_table), 1);
    }
    if lua_mod.contains(StdLib::IO) {
        requiref(state, cstr!("io"), Some(ffi::luaopen_io), 1);
    }
    if lua_mod.contains(StdLib::OS) {
        requiref(state, cstr!("os"), Some(ffi::luaopen_os), 1);
    }
    if lua_mod.contains(StdLib::STRING) {
        requiref(state, cstr!("string"), Some(ffi::luaopen_string), 1);
    }
    #[cfg(any(rlua_lua53, rlua_lua54))]
    if lua_mod.contains(StdLib::UTF8) {
        requiref(state, cstr!("utf8"), Some(ffi::luaopen_utf8), 1);
    }
    if lua_mod.contains(StdLib::MATH) {
        requiref(state, cstr!("math"), Some(ffi::luaopen_math), 1);
    }
    if lua_mod.contains(StdLib::PACKAGE) {
        requiref(state, cstr!("package"), Some(ffi::luaopen_package), 1);
    }
    if lua_mod.contains(StdLib::DEBUG) {
        requiref(state, cstr!("debug"), Some(ffi::luaopen_debug), 1);
    }
}

pub(crate) static FUNCTION_METATABLE_REGISTRY_KEY: u8 = 0;