/// NOTE: These syscalls only support wasm_32 for now because they take u32 offset
use libc::{
    c_int, c_long, getenv, getgrnam as libc_getgrnam, getpwnam as libc_getpwnam, putenv, setenv,
    sysconf, unsetenv,
};
use std::ffi::CStr;
use std::mem;
use std::os::raw::c_char;

use super::utils::{allocate_on_stack, copy_cstr_into_wasm, copy_terminated_array_of_cstrs};
use wasmer_runtime_core::{types::Value, vm::Ctx};
//use super::EmscriptenData;

//impl Instance {
//    pub fn memory_offset_addr(&self, index: usize, offset: usize) -> *const usize {
//        unimplemented!("TODO replace this stub")
//    }
//
//    pub fn emscripten_data(&self) -> &'static mut Option<EmscriptenData> {
//        unimplemented!("TODO replace this stub")
//    }
//}

// #[no_mangle]
/// emscripten: _getenv // (name: *const char) -> *const c_char;
pub extern "C" fn _getenv(name: c_int, vmctx: &mut Ctx) -> u32 {
    debug!("emscripten::_getenv");

    let name_addr = vmctx.memory(0)[name as usize] as *const c_char;

    debug!("=> name({:?})", unsafe { CStr::from_ptr(name_addr) });

    let c_str = unsafe { getenv(name_addr) };
    if c_str.is_null() {
        return 0;
    }

    unsafe { copy_cstr_into_wasm(vmctx, c_str) }
}

/// emscripten: _setenv // (name: *const char, name: *const value, overwrite: int);
pub extern "C" fn _setenv(name: c_int, value: c_int, overwrite: c_int, vmctx: &mut Ctx) -> c_int {
    debug!("emscripten::_setenv");

    let name_addr = vmctx.memory(0)[name as usize] as *const c_char;
    let value_addr = vmctx.memory(0)[value as usize] as *const c_char;

    debug!("=> name({:?})", unsafe { CStr::from_ptr(name_addr) });
    debug!("=> value({:?})", unsafe { CStr::from_ptr(value_addr) });

    unsafe { setenv(name_addr, value_addr, overwrite) }
}

/// emscripten: _putenv // (name: *const char);
pub extern "C" fn _putenv(name: c_int, vmctx: &mut Ctx) -> c_int {
    debug!("emscripten::_putenv");

    let name_addr = vmctx.memory(0)[name as usize] as *const c_char;

    debug!("=> name({:?})", unsafe { CStr::from_ptr(name_addr) });

    unsafe { putenv(name_addr as _) }
}

/// emscripten: _unsetenv // (name: *const char);
pub extern "C" fn _unsetenv(name: c_int, vmctx: &mut Ctx) -> c_int {
    debug!("emscripten::_unsetenv");

    let name_addr = vmctx.memory(0)[name as usize] as *const c_char;

    debug!("=> name({:?})", unsafe { CStr::from_ptr(name_addr) });

    unsafe { unsetenv(name_addr) }
}

#[allow(clippy::cast_ptr_alignment)]
pub extern "C" fn _getpwnam(name_ptr: c_int, vmctx: &mut Ctx) -> c_int {
    debug!("emscripten::_getpwnam {}", name_ptr);

    #[repr(C)]
    struct GuestPasswd {
        pw_name: u32,
        pw_passwd: u32,
        pw_uid: u32,
        pw_gid: u32,
        pw_gecos: u32,
        pw_dir: u32,
        pw_shell: u32,
    }

    let name = unsafe {
        let memory_name_ptr = vmctx.memory(0)[name_ptr as usize] as *const c_char;
        CStr::from_ptr(memory_name_ptr)
    };

    unsafe {
        let passwd = &*libc_getpwnam(name.as_ptr());
        let passwd_struct_offset = call_malloc(mem::size_of::<GuestPasswd>() as _, vmctx);

        let passwd_struct_ptr = vmctx.memory(0)[passwd_struct_offset as usize] as *mut GuestPasswd;
        (*passwd_struct_ptr).pw_name = copy_cstr_into_wasm(vmctx, passwd.pw_name);
        (*passwd_struct_ptr).pw_passwd = copy_cstr_into_wasm(vmctx, passwd.pw_passwd);
        (*passwd_struct_ptr).pw_gecos = copy_cstr_into_wasm(vmctx, passwd.pw_gecos);
        (*passwd_struct_ptr).pw_dir = copy_cstr_into_wasm(vmctx, passwd.pw_dir);
        (*passwd_struct_ptr).pw_shell = copy_cstr_into_wasm(vmctx, passwd.pw_shell);
        (*passwd_struct_ptr).pw_uid = passwd.pw_uid;
        (*passwd_struct_ptr).pw_gid = passwd.pw_gid;

        passwd_struct_offset as c_int
    }
}

#[allow(clippy::cast_ptr_alignment)]
pub extern "C" fn _getgrnam(name_ptr: c_int, vmctx: &mut Ctx) -> c_int {
    debug!("emscripten::_getgrnam {}", name_ptr);

    #[repr(C)]
    struct GuestGroup {
        gr_name: u32,
        gr_passwd: u32,
        gr_gid: u32,
        gr_mem: u32,
    }

    let name = unsafe {
        let memory_name_ptr = vmctx.memory(0)[name_ptr as usize] as *const c_char;
        CStr::from_ptr(memory_name_ptr)
    };

    unsafe {
        let group = &*libc_getgrnam(name.as_ptr());
        let group_struct_offset = call_malloc(mem::size_of::<GuestGroup>() as _, vmctx);

        let group_struct_ptr = vmctx.memory(0)[group_struct_offset as usize] as *mut GuestGroup;
        (*group_struct_ptr).gr_name = copy_cstr_into_wasm(vmctx, group.gr_name);
        (*group_struct_ptr).gr_passwd = copy_cstr_into_wasm(vmctx, group.gr_passwd);
        (*group_struct_ptr).gr_gid = group.gr_gid;
        (*group_struct_ptr).gr_mem = copy_terminated_array_of_cstrs(vmctx, group.gr_mem);

        group_struct_offset as c_int
    }
}

pub fn call_malloc(size: i32, vmctx: &mut Ctx) -> u32 {
    unimplemented!()
//    let ret = instance
//        .call("_malloc", &[Value::I32(size)])
//        .expect("_malloc call failed");
//    if let [Value::I32(x)] = ret.as_slice() {
//        *x as u32
//    } else {
//        panic!("unexpected value from _malloc: {:?}", ret);
//    }
}

pub fn call_memalign(alignment: u32, size: u32, vmctx: &mut Ctx) -> u32 {
    unimplemented!()
    // let ret =
    //     call(
    //         vmctx,
    //         "_memalign",
    //         &[Value::I32(alignment as i32), Value::I32(size as i32)],
    //     )
    //     .expect("_memalign call failed");
    // if let [Value::I32(x)] = ret.as_slice() {
    //     *x as u32
    // } else {
    //     panic!("unexpected value from _memalign {:?}", ret);
    // }
}

pub fn call_memset(pointer: u32, value: i32, size: u32, vmctx: &mut Ctx) -> u32 {
    unimplemented!()
//    let ret = instance
//        .call(
//            "_memset",
//            &[
//                Value::I32(pointer as i32),
//                Value::I32(value),
//                Value::I32(size as i32),
//            ],
//        )
//        .expect("_memset call failed");
//    if let [Value::I32(x)] = ret.as_slice() {
//        *x as u32
//    } else {
//        panic!("unexpected value from _memset {:?}", ret);
//    }
}

pub extern "C" fn _getpagesize() -> u32 {
    debug!("emscripten::_getpagesize");
    16384
}

#[allow(clippy::cast_ptr_alignment)]
pub extern "C" fn ___build_environment(environ: c_int, vmctx: &mut Ctx) {
    debug!("emscripten::___build_environment {}", environ);
    const MAX_ENV_VALUES: u32 = 64;
    const TOTAL_ENV_SIZE: u32 = 1024;
    let mut environment = vmctx.memory(0)[environ as usize] as *mut c_int;
    unsafe {
        let (pool_offset, _pool_slice): (u32, &mut [u8]) =
            allocate_on_stack(TOTAL_ENV_SIZE as u32, vmctx);
        let (env_offset, _env_slice): (u32, &mut [u8]) =
            allocate_on_stack((MAX_ENV_VALUES * 4) as u32, vmctx);
        let mut env_ptr = vmctx.memory(0)[env_offset as usize] as *mut c_int;
        let mut _pool_ptr = vmctx.memory(0)[pool_offset as usize] as *mut c_int;
        *env_ptr = pool_offset as i32;
        *environment = env_offset as i32;

        // *env_ptr = 0;
    };
    // unsafe {
    //     *env_ptr = 0;
    // };
}

pub extern "C" fn _sysconf(name: c_int, _vmctx: &mut Ctx) -> c_long {
    debug!("emscripten::_sysconf {}", name);
    // TODO: Implement like emscripten expects regarding memory/page size
    unsafe { sysconf(name) }
}

pub extern "C" fn ___assert_fail(a: c_int, b: c_int, c: c_int, d: c_int, _vmctx: &mut Ctx) {
    debug!("emscripten::___assert_fail {} {} {} {}", a, b, c, d);
    // TODO: Implement like emscripten expects regarding memory/page size
    unimplemented!()
}