#![cfg(test)]

use std::{
    ffi::CString,
    sync::atomic::{AtomicU32, Ordering},
};

use nixide_sys::*;
use serial_test::serial;

#[derive(Debug)]
struct TestPrimOpData {
    call_count: AtomicU32,
    last_arg_value: AtomicU32,
}

// Simple PrimOp that adds 1 to an integer argument
unsafe extern "C" fn add_one_primop(
    user_data: *mut ::std::os::raw::c_void,
    context: *mut nix_c_context,
    state: *mut EvalState,
    args: *mut *mut nix_value,
    ret: *mut nix_value,
) {
    if user_data.is_null()
        || context.is_null()
        || state.is_null()
        || args.is_null()
        || ret.is_null()
    {
        let _ = unsafe {
            nix_set_err_msg(
                context,
                nix_err_NIX_ERR_UNKNOWN,
                b"Null pointer in add_one_primop\0".as_ptr() as *const _,
            )
        };
        return;
    }

    let data = unsafe { &*(user_data as *const TestPrimOpData) };
    data.call_count.fetch_add(1, Ordering::SeqCst);

    // Get first argument
    let arg = unsafe { *args.offset(0) };
    if arg.is_null() {
        let _ = unsafe {
            nix_set_err_msg(
                context,
                nix_err_NIX_ERR_UNKNOWN,
                b"Missing argument in add_one_primop\0".as_ptr() as *const _,
            )
        };
        return;
    }

    // Force evaluation of argument
    if unsafe { nix_value_force(context, state, arg) } != nix_err_NIX_OK {
        return;
    }

    // Check if argument is integer
    if unsafe { nix_get_type(context, arg) } != ValueType_NIX_TYPE_INT {
        let _ = unsafe {
            nix_set_err_msg(
                context,
                nix_err_NIX_ERR_UNKNOWN,
                b"Expected integer argument in add_one_primop\0".as_ptr() as *const _,
            )
        };
        return;
    }

    // Get integer value and add 1
    let value = unsafe { nix_get_int(context, arg) };
    data.last_arg_value.store(value as u32, Ordering::SeqCst);

    // Set return value
    let _ = unsafe { nix_init_int(context, ret, value + 1) };
}

// PrimOp that returns a constant string
unsafe extern "C" fn hello_world_primop(
    _user_data: *mut ::std::os::raw::c_void,
    context: *mut nix_c_context,
    _state: *mut EvalState,
    _args: *mut *mut nix_value,
    ret: *mut nix_value,
) {
    let hello = CString::new("Hello from Rust PrimOp!").unwrap();
    let _ = unsafe { nix_init_string(context, ret, hello.as_ptr()) };
}

// PrimOp that takes multiple arguments and concatenates them
unsafe extern "C" fn concat_strings_primop(
    _user_data: *mut ::std::os::raw::c_void,
    context: *mut nix_c_context,
    state: *mut EvalState,
    args: *mut *mut nix_value,
    ret: *mut nix_value,
) {
    if context.is_null() || state.is_null() || args.is_null() || ret.is_null() {
        return;
    }

    // This PrimOp expects exactly 2 string arguments
    let mut result = String::new();

    for i in 0..2 {
        let arg = unsafe { *args.offset(i) };
        if arg.is_null() {
            let _ = unsafe {
                nix_set_err_msg(
                    context,
                    nix_err_NIX_ERR_UNKNOWN,
                    b"Missing argument in concat_strings_primop\0".as_ptr() as *const _,
                )
            };
            return;
        }

        // Force evaluation
        if unsafe { nix_value_force(context, state, arg) } != nix_err_NIX_OK {
            return;
        }

        // Check if it's a string
        if unsafe { nix_get_type(context, arg) } != ValueType_NIX_TYPE_STRING {
            let _ = unsafe {
                static ITEMS: &[u8] = b"Expected string argument in concat_strings_primop\0";
                nix_set_err_msg(context, nix_err_NIX_ERR_UNKNOWN, ITEMS.as_ptr() as *const _)
            };
            return;
        }

        // Get string value using callback
        unsafe extern "C" fn string_callback(
            start: *const ::std::os::raw::c_char,
            n: ::std::os::raw::c_uint,
            user_data: *mut ::std::os::raw::c_void,
        ) {
            let s = unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) };
            let s = std::str::from_utf8(s).unwrap_or("");
            let result = unsafe { &mut *(user_data as *mut String) };
            result.push_str(s);
        }

        let _ = unsafe {
            nix_get_string(
                context,
                arg,
                Some(string_callback),
                &mut result as *mut String as *mut ::std::os::raw::c_void,
            )
        };
    }

    let result_cstr = CString::new(result).unwrap_or_else(|_| CString::new("").unwrap());
    let _ = unsafe { nix_init_string(context, ret, result_cstr.as_ptr()) };
}

#[test]
#[serial]
fn primop_allocation_and_registration() {
    unsafe {
        let ctx = nix_c_context_create();
        assert!(!ctx.is_null());

        let err = nix_libutil_init(ctx);
        assert_eq!(err, nix_err_NIX_OK);

        let err = nix_libstore_init(ctx);
        assert_eq!(err, nix_err_NIX_OK);

        let err = nix_libexpr_init(ctx);
        assert_eq!(err, nix_err_NIX_OK);

        let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
        assert!(!store.is_null());

        let builder = nix_eval_state_builder_new(ctx, store);
        assert!(!builder.is_null());

        let load_err = nix_eval_state_builder_load(ctx, builder);
        assert_eq!(load_err, nix_err_NIX_OK);

        let state = nix_eval_state_build(ctx, builder);
        assert!(!state.is_null());

        // Create test data
        let test_data = Box::new(TestPrimOpData {
            call_count: AtomicU32::new(0),
            last_arg_value: AtomicU32::new(0),
        });
        let test_data_ptr = Box::into_raw(test_data);

        // Create argument names
        let arg_names = [CString::new("x").unwrap()];
        let arg_name_ptrs: Vec<*const _> = arg_names.iter().map(|s| s.as_ptr()).collect();
        let mut arg_name_ptrs_null_terminated = arg_name_ptrs;
        arg_name_ptrs_null_terminated.push(std::ptr::null());

        let name = CString::new("addOne").unwrap();
        let doc = CString::new("Add 1 to the argument").unwrap();

        // Allocate PrimOp
        let primop = nix_alloc_primop(
            ctx,
            Some(add_one_primop),
            1, // arity
            name.as_ptr(),
            arg_name_ptrs_null_terminated.as_mut_ptr(),
            doc.as_ptr(),
            test_data_ptr as *mut ::std::os::raw::c_void,
        );

        if !primop.is_null() {
            // Register the PrimOp globally
            let register_err = nix_register_primop(ctx, primop);
            // Registration may fail in some environments, but allocation should work
            assert!(
                register_err == nix_err_NIX_OK || register_err == nix_err_NIX_ERR_UNKNOWN,
                "Unexpected error code: {register_err}"
            );

            // Test using the PrimOp by creating a value with it
            let primop_value = nix_alloc_value(ctx, state);
            assert!(!primop_value.is_null());

            let init_err = nix_init_primop(ctx, primop_value, primop);
            assert_eq!(init_err, nix_err_NIX_OK);

            // Clean up value
            nix_value_decref(ctx, primop_value);
        }

        // Clean up
        let _ = Box::from_raw(test_data_ptr);
        nix_state_free(state);
        nix_eval_state_builder_free(builder);
        nix_store_free(store);
        nix_c_context_free(ctx);
    }
}

#[test]
#[serial]
fn primop_function_call() {
    unsafe {
        let ctx = nix_c_context_create();
        assert!(!ctx.is_null());

        let err = nix_libutil_init(ctx);
        assert_eq!(err, nix_err_NIX_OK);

        let err = nix_libstore_init(ctx);
        assert_eq!(err, nix_err_NIX_OK);

        let err = nix_libexpr_init(ctx);
        assert_eq!(err, nix_err_NIX_OK);

        let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
        assert!(!store.is_null());

        let builder = nix_eval_state_builder_new(ctx, store);
        assert!(!builder.is_null());

        let load_err = nix_eval_state_builder_load(ctx, builder);
        assert_eq!(load_err, nix_err_NIX_OK);

        let state = nix_eval_state_build(ctx, builder);
        assert!(!state.is_null());

        // Create test data
        let test_data = Box::new(TestPrimOpData {
            call_count: AtomicU32::new(0),
            last_arg_value: AtomicU32::new(0),
        });
        let test_data_ptr = Box::into_raw(test_data);

        // Create simple hello world PrimOp (no arguments)
        let name = CString::new("helloWorld").unwrap();
        let doc = CString::new("Returns hello world string").unwrap();
        let mut empty_args: Vec<*const ::std::os::raw::c_char> = vec![std::ptr::null()];

        let hello_primop = nix_alloc_primop(
            ctx,
            Some(hello_world_primop),
            0, // arity
            name.as_ptr(),
            empty_args.as_mut_ptr(),
            doc.as_ptr(),
            std::ptr::null_mut(),
        );

        if !hello_primop.is_null() {
            // Create a value with the PrimOp
            let primop_value = nix_alloc_value(ctx, state);
            assert!(!primop_value.is_null());

            let init_err = nix_init_primop(ctx, primop_value, hello_primop);
            assert_eq!(init_err, nix_err_NIX_OK);

            // Call the PrimOp (no arguments)
            let result = nix_alloc_value(ctx, state);
            assert!(!result.is_null());

            let call_err = nix_value_call(ctx, state, primop_value, std::ptr::null_mut(), result);
            if call_err == nix_err_NIX_OK {
                // Force the result
                let force_err = nix_value_force(ctx, state, result);
                assert_eq!(force_err, nix_err_NIX_OK);

                // Check if result is a string
                let result_type = nix_get_type(ctx, result);
                if result_type == ValueType_NIX_TYPE_STRING {
                    // Get string value
                    unsafe extern "C" fn string_callback(
                        start: *const ::std::os::raw::c_char,
                        n: ::std::os::raw::c_uint,
                        user_data: *mut ::std::os::raw::c_void,
                    ) {
                        let s =
                            unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) };
                        let s = std::str::from_utf8(s).unwrap_or("");
                        let result = unsafe { &mut *(user_data as *mut Option<String>) };
                        *result = Some(s.to_string());
                    }

                    let mut string_result: Option<String> = None;
                    let _ = nix_get_string(
                        ctx,
                        result,
                        Some(string_callback),
                        &mut string_result as *mut Option<String> as *mut ::std::os::raw::c_void,
                    );

                    // Verify we got the expected string
                    assert!(string_result
                        .as_deref()
                        .unwrap_or("")
                        .contains("Hello from Rust"));
                }
            }

            nix_value_decref(ctx, result);
            nix_value_decref(ctx, primop_value);
        }

        // Clean up
        let _ = Box::from_raw(test_data_ptr);
        nix_state_free(state);
        nix_eval_state_builder_free(builder);
        nix_store_free(store);
        nix_c_context_free(ctx);
    }
}

#[test]
#[serial]
fn primop_with_arguments() {
    unsafe {
        let ctx = nix_c_context_create();
        assert!(!ctx.is_null());

        let err = nix_libutil_init(ctx);
        assert_eq!(err, nix_err_NIX_OK);

        let err = nix_libstore_init(ctx);
        assert_eq!(err, nix_err_NIX_OK);

        let err = nix_libexpr_init(ctx);
        assert_eq!(err, nix_err_NIX_OK);

        let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
        assert!(!store.is_null());

        let builder = nix_eval_state_builder_new(ctx, store);
        assert!(!builder.is_null());

        let load_err = nix_eval_state_builder_load(ctx, builder);
        assert_eq!(load_err, nix_err_NIX_OK);

        let state = nix_eval_state_build(ctx, builder);
        assert!(!state.is_null());

        // Create test data
        let test_data = Box::new(TestPrimOpData {
            call_count: AtomicU32::new(0),
            last_arg_value: AtomicU32::new(0),
        });
        let test_data_ptr = Box::into_raw(test_data);

        // Create add one PrimOp
        let arg_names = [CString::new("x").unwrap()];
        let arg_name_ptrs: Vec<*const _> = arg_names.iter().map(|s| s.as_ptr()).collect();
        let mut arg_name_ptrs_null_terminated = arg_name_ptrs;
        arg_name_ptrs_null_terminated.push(std::ptr::null());

        let name = CString::new("addOne").unwrap();
        let doc = CString::new("Add 1 to the argument").unwrap();

        let add_primop = nix_alloc_primop(
            ctx,
            Some(add_one_primop),
            1, // arity
            name.as_ptr(),
            arg_name_ptrs_null_terminated.as_mut_ptr(),
            doc.as_ptr(),
            test_data_ptr as *mut ::std::os::raw::c_void,
        );

        if !add_primop.is_null() {
            // Create a value with the PrimOp
            let primop_value = nix_alloc_value(ctx, state);
            assert!(!primop_value.is_null());

            let init_err = nix_init_primop(ctx, primop_value, add_primop);
            assert_eq!(init_err, nix_err_NIX_OK);

            // Create an integer argument
            let arg_value = nix_alloc_value(ctx, state);
            assert!(!arg_value.is_null());

            let init_arg_err = nix_init_int(ctx, arg_value, 42);
            assert_eq!(init_arg_err, nix_err_NIX_OK);

            // Call the PrimOp with the argument
            let result = nix_alloc_value(ctx, state);
            assert!(!result.is_null());

            let call_err = nix_value_call(ctx, state, primop_value, arg_value, result);
            if call_err == nix_err_NIX_OK {
                // Force the result
                let force_err = nix_value_force(ctx, state, result);
                assert_eq!(force_err, nix_err_NIX_OK);

                // Check if result is an integer
                let result_type = nix_get_type(ctx, result);
                if result_type == ValueType_NIX_TYPE_INT {
                    let result_value = nix_get_int(ctx, result);
                    assert_eq!(result_value, 43); // 42 + 1

                    // Verify callback was called
                    let test_data_ref = &*test_data_ptr;
                    assert_eq!(test_data_ref.call_count.load(Ordering::SeqCst), 1);
                    assert_eq!(test_data_ref.last_arg_value.load(Ordering::SeqCst), 42);
                }
            }

            nix_value_decref(ctx, result);
            nix_value_decref(ctx, arg_value);
            nix_value_decref(ctx, primop_value);
        }

        // Clean up
        let _ = Box::from_raw(test_data_ptr);
        nix_state_free(state);
        nix_eval_state_builder_free(builder);
        nix_store_free(store);
        nix_c_context_free(ctx);
    }
}

#[test]
#[serial]
fn primop_multi_argument() {
    unsafe {
        let ctx = nix_c_context_create();
        assert!(!ctx.is_null());

        let err = nix_libutil_init(ctx);
        assert_eq!(err, nix_err_NIX_OK);

        let err = nix_libstore_init(ctx);
        assert_eq!(err, nix_err_NIX_OK);

        let err = nix_libexpr_init(ctx);
        assert_eq!(err, nix_err_NIX_OK);

        let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
        assert!(!store.is_null());

        let builder = nix_eval_state_builder_new(ctx, store);
        assert!(!builder.is_null());

        let load_err = nix_eval_state_builder_load(ctx, builder);
        assert_eq!(load_err, nix_err_NIX_OK);

        let state = nix_eval_state_build(ctx, builder);
        assert!(!state.is_null());

        // Create concat strings PrimOp
        let arg_names = [CString::new("s1").unwrap(), CString::new("s2").unwrap()];
        let arg_name_ptrs: Vec<*const _> = arg_names.iter().map(|s| s.as_ptr()).collect();
        let mut arg_name_ptrs_null_terminated = arg_name_ptrs;
        arg_name_ptrs_null_terminated.push(std::ptr::null());

        let name = CString::new("concatStrings").unwrap();
        let doc = CString::new("Concatenate two strings").unwrap();

        let concat_primop = nix_alloc_primop(
            ctx,
            Some(concat_strings_primop),
            2, // arity
            name.as_ptr(),
            arg_name_ptrs_null_terminated.as_mut_ptr(),
            doc.as_ptr(),
            std::ptr::null_mut(),
        );

        if !concat_primop.is_null() {
            // Create a value with the PrimOp
            let primop_value = nix_alloc_value(ctx, state);
            assert!(!primop_value.is_null());

            let init_err = nix_init_primop(ctx, primop_value, concat_primop);
            assert_eq!(init_err, nix_err_NIX_OK);

            // Create string arguments
            let arg1 = nix_alloc_value(ctx, state);
            let arg2 = nix_alloc_value(ctx, state);
            assert!(!arg1.is_null() && !arg2.is_null());

            let hello_cstr = CString::new("Hello, ").unwrap();
            let world_cstr = CString::new("World!").unwrap();

            let init_arg1_err = nix_init_string(ctx, arg1, hello_cstr.as_ptr());
            let init_arg2_err = nix_init_string(ctx, arg2, world_cstr.as_ptr());
            assert_eq!(init_arg1_err, nix_err_NIX_OK);
            assert_eq!(init_arg2_err, nix_err_NIX_OK);

            // Test multi-argument call using nix_value_call_multi
            let mut args = [arg1, arg2];
            let result = nix_alloc_value(ctx, state);
            assert!(!result.is_null());

            let call_err =
                nix_value_call_multi(ctx, state, primop_value, 2, args.as_mut_ptr(), result);
            if call_err == nix_err_NIX_OK {
                // Force the result
                let force_err = nix_value_force(ctx, state, result);
                assert_eq!(force_err, nix_err_NIX_OK);

                // Check if result is a string
                let result_type = nix_get_type(ctx, result);
                if result_type == ValueType_NIX_TYPE_STRING {
                    unsafe extern "C" fn string_callback(
                        start: *const ::std::os::raw::c_char,
                        n: ::std::os::raw::c_uint,
                        user_data: *mut ::std::os::raw::c_void,
                    ) {
                        let s =
                            unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) };
                        let s = std::str::from_utf8(s).unwrap_or("");
                        let result = unsafe { &mut *(user_data as *mut Option<String>) };
                        *result = Some(s.to_string());
                    }

                    let mut string_result: Option<String> = None;
                    let _ = nix_get_string(
                        ctx,
                        result,
                        Some(string_callback),
                        &mut string_result as *mut Option<String> as *mut ::std::os::raw::c_void,
                    );

                    // Verify concatenation worked
                    assert_eq!(string_result.as_deref(), Some("Hello, World!"));
                }
            }

            nix_value_decref(ctx, result);
            nix_value_decref(ctx, arg2);
            nix_value_decref(ctx, arg1);
            nix_value_decref(ctx, primop_value);
        }

        nix_state_free(state);
        nix_eval_state_builder_free(builder);
        nix_store_free(store);
        nix_c_context_free(ctx);
    }
}

#[test]
#[serial]
fn primop_error_handling() {
    unsafe {
        let ctx = nix_c_context_create();
        assert!(!ctx.is_null());

        let err = nix_libutil_init(ctx);
        assert_eq!(err, nix_err_NIX_OK);

        let err = nix_libstore_init(ctx);
        assert_eq!(err, nix_err_NIX_OK);

        let err = nix_libexpr_init(ctx);
        assert_eq!(err, nix_err_NIX_OK);

        let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
        assert!(!store.is_null());

        let builder = nix_eval_state_builder_new(ctx, store);
        assert!(!builder.is_null());

        let load_err = nix_eval_state_builder_load(ctx, builder);
        assert_eq!(load_err, nix_err_NIX_OK);

        let state = nix_eval_state_build(ctx, builder);
        assert!(!state.is_null());

        // Test invalid PrimOp allocation (NULL callback)
        let name = CString::new("invalid").unwrap();
        let doc = CString::new("Invalid PrimOp").unwrap();
        let mut empty_args: Vec<*const ::std::os::raw::c_char> = vec![std::ptr::null()];

        let _invalid_primop = nix_alloc_primop(
            ctx,
            None, // NULL callback should cause error
            0,
            name.as_ptr(),
            empty_args.as_mut_ptr(),
            doc.as_ptr(),
            std::ptr::null_mut(),
        );

        // Test initializing value with NULL PrimOp (should fail)
        let test_value = nix_alloc_value(ctx, state);
        assert!(!test_value.is_null());

        nix_value_decref(ctx, test_value);
        nix_state_free(state);
        nix_eval_state_builder_free(builder);
        nix_store_free(store);
        nix_c_context_free(ctx);
    }
}