#![allow(non_upper_case_globals)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(dead_code)]
#![allow(unused_imports)]
#![allow(improper_ctypes)]

use std::ffi::CStr;

include!(concat!(env!("OUT_DIR"), "/bindings.rs"));

pub const PyObject_HEAD_INIT: PyObject = PyObject {
    __bindgen_anon_1: _object__bindgen_ty_1 { ob_refcnt: 1 },
    ob_type: std::ptr::null_mut(),
};

pub const PyModuleDef_HEAD_INIT: PyModuleDef_Base = PyModuleDef_Base {
    ob_base: PyObject_HEAD_INIT,
    m_init: None,
    m_index: 0,
    m_copy: std::ptr::null_mut(),
};

pub fn safe_shit_func(data: &str) -> usize {
    return data.len();
}

unsafe extern "C" fn py_shit_func(_mod_self: *mut PyObject, args: *mut PyObject) -> *mut PyObject {
    let mut ptr = std::ptr::null();
    let parsed = unsafe { PyArg_ParseTuple(args, c"s".as_ptr(), &mut ptr) };
    if parsed == 0 {
        return std::ptr::null::<PyObject>() as *mut _;
    }
    let Ok(read_arg) = unsafe { CStr::from_ptr(ptr) }.to_str() else {
        unsafe { PyErr_SetString(PyExc_RuntimeError, c"Not an UTF-8 string".as_ptr()) };
        return std::ptr::null::<PyObject>() as *mut _;
    };
    let ret = safe_shit_func(read_arg);
    return unsafe { PyLong_FromSize_t(ret) };
}

#[unsafe(no_mangle)]
pub unsafe extern "C" fn PyInit_libpyrtest() -> *mut PyObject {
    let slots = vec![
        PyModuleDef_Slot {
            slot: Py_mod_multiple_interpreters as i32,
            value: 2 as *mut std::ffi::c_void,
        },
        PyModuleDef_Slot {
            slot: 0,
            value: std::ptr::null_mut(),
        },
    ]
    .into_boxed_slice();
    let slots_ptr: *mut PyModuleDef_Slot = Box::into_raw(slots) as *mut _;

    let methods: Box<[PyMethodDef]> = vec![
        PyMethodDef {
            ml_name: c"shit".as_ptr(),
            ml_meth: Some(py_shit_func),
            ml_flags: METH_VARARGS as i32,
            ml_doc: c"Shit function for you all fools".as_ptr(),
        },
        PyMethodDef {
            ml_name: std::ptr::null(),
            ml_meth: None,
            ml_flags: 0,
            ml_doc: std::ptr::null(),
        },
    ]
    .into_boxed_slice();
    let methods_ptr: *mut _ = Box::into_raw(methods) as *mut _;

    let my_mod = PyModuleDef {
        m_base: PyModuleDef_HEAD_INIT,
        m_name: c"libpyrstest".as_ptr(),
        m_doc: c"My cool rust module".as_ptr(),
        m_size: 0,
        m_methods: methods_ptr,
        m_slots: slots_ptr,
        m_traverse: None,
        m_clear: None,
        m_free: None,
    };
    let raw_mod = Box::into_raw(Box::new(my_mod));
    return unsafe { PyModuleDef_Init(raw_mod) };
}