use core::{slice, str};
use std::alloc::Layout;
use std::alloc::alloc;
use std::mem::MaybeUninit;
use std::ptr::NonNull;

use crate::env::Env;
use crate::eval::Engine;
use crate::ty::internal::Value;

pub extern "C" fn helper_call(
    func: &mut Value,
    args_ptr: *mut Value,
    args_len: usize,
    engine: &mut Engine,
    env: &mut Env,
) {
    // TODO: Error Handling
    let args = core::ptr::slice_from_raw_parts_mut(args_ptr, args_len);
    let args = unsafe { Box::from_raw(args) };
    func.call(args.into_iter().map(Value::from).collect(), engine, env)
        .unwrap();
}

pub extern "C" fn helper_lookup_arg(env: &Env, level: usize, ret: &mut MaybeUninit<Value>) {
    ret.write(env.lookup_arg(level as usize));
}

pub extern "C" fn helper_lookup(
    env: &Env,
    sym_ptr: *const u8,
    sym_len: usize,
    ret: &mut MaybeUninit<Value>,
) {
    // TODO: Error Handling
    unsafe {
        ret.write(
            env.lookup_with(str::from_utf8_unchecked(slice::from_raw_parts(
                sym_ptr, sym_len,
            )))
            .unwrap(),
        );
    }
}

pub extern "C" fn helper_select(
    val: &mut Value,
    path_ptr: *mut Value,
    path_len: usize,
    engine: &mut Engine,
    env: &mut Env,
) {
    let path = core::ptr::slice_from_raw_parts_mut(path_ptr, path_len);
    let path = unsafe { Box::from_raw(path) };
    val.select(path.into_iter().map(|mut val| {
        val.force(engine, env)?.coerce_to_string();
        Ok(val.unwrap_string())
    }))
    .unwrap();
}

pub extern "C" fn helper_select_with_default(
    val: &mut Value,
    path_ptr: *mut Value,
    path_len: usize,
    default: NonNull<Value>,
    engine: &mut Engine,
    env: &mut Env,
) {
    let path = core::ptr::slice_from_raw_parts_mut(path_ptr, path_len);
    let path = unsafe { Box::from_raw(path) };
    val.select_with_default(
        path.into_iter().map(|mut val| {
            val.force(engine, env)?.coerce_to_string();
            Ok(val.unwrap_string())
        }),
        unsafe { default.read() },
    )
    .unwrap();
}

pub extern "C" fn helper_force(thunk: &mut Value, engine: &mut Engine, env: &mut Env) {
    thunk.force(engine, env).unwrap();
}

pub extern "C" fn helper_eq(lhs: &mut Value, rhs: &Value) {
    lhs.eq(rhs);
}

pub unsafe extern "C" fn helper_create_string(
    ptr: *const u8,
    len: usize,
    ret: &mut MaybeUninit<Value>,
) {
    unsafe {
        ret.write(Value::String(
            str::from_utf8_unchecked(slice::from_raw_parts(ptr, len)).to_string(),
        ));
    }
}

pub unsafe extern "C" fn helper_alloc_array(len: usize) -> *mut u8 {
    unsafe { alloc(Layout::array::<Value>(len).unwrap()) }
}

pub extern "C" fn helper_dbg(value: &Value) {
    // dbg!(value);
    println!("{value:?}")
}