use core::ptr;
use libc::{c_char, c_double, c_int, c_long, c_uint, c_void, FILE};

use crate::methodobject::PyMethodDef;
use crate::pyport::Py_ssize_t;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct PyObject {
    #[cfg(py_sys_config = "Py_TRACE_REFS")]
    pub _ob_next: *mut PyObject,
    #[cfg(py_sys_config = "Py_TRACE_REFS")]
    pub _ob_prev: *mut PyObject,
    pub ob_refcnt: Py_ssize_t,
    pub ob_type: *mut PyTypeObject,
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct PyVarObject {
    #[cfg(py_sys_config = "Py_TRACE_REFS")]
    pub _ob_next: *mut PyObject,
    #[cfg(py_sys_config = "Py_TRACE_REFS")]
    pub _ob_prev: *mut PyObject,
    pub ob_refcnt: Py_ssize_t,
    pub ob_type: *mut PyTypeObject,
    pub ob_size: Py_ssize_t,
}

#[inline(always)]
pub unsafe fn Py_REFCNT(ob: *mut PyObject) -> Py_ssize_t {
    (*ob).ob_refcnt
}

#[inline(always)]
pub unsafe fn Py_TYPE(ob: *mut PyObject) -> *mut PyTypeObject {
    (*ob).ob_type
}

#[inline(always)]
pub unsafe fn Py_SIZE(ob: *mut PyObject) -> Py_ssize_t {
    (*(ob as *mut PyVarObject)).ob_size
}

pub type unaryfunc = unsafe extern "C" fn(arg1: *mut PyObject) -> *mut PyObject;
pub type binaryfunc =
    unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject;
pub type ternaryfunc = unsafe extern "C" fn(
    arg1: *mut PyObject,
    arg2: *mut PyObject,
    arg3: *mut PyObject,
) -> *mut PyObject;
pub type inquiry = unsafe extern "C" fn(arg1: *mut PyObject) -> c_int;
pub type lenfunc = unsafe extern "C" fn(arg1: *mut PyObject) -> Py_ssize_t;
pub type coercion =
    unsafe extern "C" fn(arg1: *mut *mut PyObject, arg2: *mut *mut PyObject) -> c_int;
pub type ssizeargfunc =
    unsafe extern "C" fn(arg1: *mut PyObject, arg2: Py_ssize_t) -> *mut PyObject;
pub type ssizessizeargfunc =
    unsafe extern "C" fn(arg1: *mut PyObject, arg2: Py_ssize_t, arg3: Py_ssize_t) -> *mut PyObject;
pub type intobjargproc =
    unsafe extern "C" fn(arg1: *mut PyObject, arg2: c_int, arg3: *mut PyObject) -> c_int;
pub type intintobjargproc = unsafe extern "C" fn(
    arg1: *mut PyObject,
    arg2: c_int,
    arg3: c_int,
    arg4: *mut PyObject,
) -> c_int;
pub type ssizeobjargproc =
    unsafe extern "C" fn(arg1: *mut PyObject, arg2: Py_ssize_t, arg3: *mut PyObject) -> c_int;
pub type ssizessizeobjargproc = unsafe extern "C" fn(
    arg1: *mut PyObject,
    arg2: Py_ssize_t,
    arg3: Py_ssize_t,
    arg4: *mut PyObject,
) -> c_int;
pub type objobjargproc =
    unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject) -> c_int;
pub type getreadbufferproc =
    unsafe extern "C" fn(arg1: *mut PyObject, arg2: c_int, arg3: *mut *mut c_void) -> c_int;
pub type getwritebufferproc =
    unsafe extern "C" fn(arg1: *mut PyObject, arg2: c_int, arg3: *mut *mut c_void) -> c_int;
pub type getsegcountproc = unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut c_int) -> c_int;
pub type getcharbufferproc =
    unsafe extern "C" fn(arg1: *mut PyObject, arg2: c_int, arg3: *mut *mut c_char) -> c_int;
pub type readbufferproc = unsafe extern "C" fn(
    arg1: *mut PyObject,
    arg2: Py_ssize_t,
    arg3: *mut *mut c_void,
) -> Py_ssize_t;
pub type writebufferproc = unsafe extern "C" fn(
    arg1: *mut PyObject,
    arg2: Py_ssize_t,
    arg3: *mut *mut c_void,
) -> Py_ssize_t;
pub type segcountproc =
    unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut Py_ssize_t) -> Py_ssize_t;
pub type charbufferproc = unsafe extern "C" fn(
    arg1: *mut PyObject,
    arg2: Py_ssize_t,
    arg3: *mut *mut c_char,
) -> Py_ssize_t;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct Py_buffer {
    pub buf: *mut c_void,
    pub obj: *mut PyObject,
    pub len: Py_ssize_t,
    pub itemsize: Py_ssize_t,
    pub readonly: c_int,
    pub ndim: c_int,
    pub format: *mut c_char,
    pub shape: *mut Py_ssize_t,
    pub strides: *mut Py_ssize_t,
    pub suboffsets: *mut Py_ssize_t,
    pub smalltable: [Py_ssize_t; 2],
    pub internal: *mut c_void,
}

pub type getbufferproc =
    unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut Py_buffer, arg3: c_int) -> c_int;
pub type releasebufferproc = unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut Py_buffer);

// flags:
pub const PyBUF_SIMPLE: c_int = 0;
pub const PyBUF_WRITABLE: c_int = 0x0001;
pub const PyBUF_FORMAT: c_int = 0x0004;
pub const PyBUF_ND: c_int = 0x0008;
pub const PyBUF_STRIDES: c_int = (0x0010 | PyBUF_ND);
pub const PyBUF_C_CONTIGUOUS: c_int = (0x0020 | PyBUF_STRIDES);
pub const PyBUF_F_CONTIGUOUS: c_int = (0x0040 | PyBUF_STRIDES);
pub const PyBUF_ANY_CONTIGUOUS: c_int = (0x0080 | PyBUF_STRIDES);
pub const PyBUF_INDIRECT: c_int = (0x0100 | PyBUF_STRIDES);

pub const PyBUF_CONTIG: c_int = (PyBUF_ND | PyBUF_WRITABLE);
pub const PyBUF_CONTIG_RO: c_int = (PyBUF_ND);

pub const PyBUF_STRIDED: c_int = (PyBUF_STRIDES | PyBUF_WRITABLE);
pub const PyBUF_STRIDED_RO: c_int = (PyBUF_STRIDES);

pub const PyBUF_RECORDS: c_int = (PyBUF_STRIDES | PyBUF_WRITABLE | PyBUF_FORMAT);
pub const PyBUF_RECORDS_RO: c_int = (PyBUF_STRIDES | PyBUF_FORMAT);

pub const PyBUF_FULL: c_int = (PyBUF_INDIRECT | PyBUF_WRITABLE | PyBUF_FORMAT);
pub const PyBUF_FULL_RO: c_int = (PyBUF_INDIRECT | PyBUF_FORMAT);

// buffertype:
pub const PyBUF_READ: c_int = 0x100;
pub const PyBUF_WRITE: c_int = 0x200;
pub const PyBUF_SHADOW: c_int = 0x400;

pub type objobjproc = unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> c_int;
pub type visitproc = unsafe extern "C" fn(object: *mut PyObject, arg: *mut c_void) -> c_int;
pub type traverseproc =
    unsafe extern "C" fn(slf: *mut PyObject, visit: visitproc, arg: *mut c_void) -> c_int;

#[repr(C)]
#[derive(Copy)]
pub struct PyNumberMethods {
    pub nb_add: Option<binaryfunc>,
    pub nb_subtract: Option<binaryfunc>,
    pub nb_multiply: Option<binaryfunc>,
    pub nb_divide: Option<binaryfunc>,
    pub nb_remainder: Option<binaryfunc>,
    pub nb_divmod: Option<binaryfunc>,
    pub nb_power: Option<ternaryfunc>,
    pub nb_negative: Option<unaryfunc>,
    pub nb_positive: Option<unaryfunc>,
    pub nb_absolute: Option<unaryfunc>,
    pub nb_nonzero: Option<inquiry>,
    pub nb_invert: Option<unaryfunc>,
    pub nb_lshift: Option<binaryfunc>,
    pub nb_rshift: Option<binaryfunc>,
    pub nb_and: Option<binaryfunc>,
    pub nb_xor: Option<binaryfunc>,
    pub nb_or: Option<binaryfunc>,
    pub nb_coerce: Option<coercion>,
    pub nb_c_int: Option<unaryfunc>,
    pub nb_long: Option<unaryfunc>,
    pub nb_float: Option<unaryfunc>,
    pub nb_oct: Option<unaryfunc>,
    pub nb_hex: Option<unaryfunc>,
    pub nb_inplace_add: Option<binaryfunc>,
    pub nb_inplace_subtract: Option<binaryfunc>,
    pub nb_inplace_multiply: Option<binaryfunc>,
    pub nb_inplace_divide: Option<binaryfunc>,
    pub nb_inplace_remainder: Option<binaryfunc>,
    pub nb_inplace_power: Option<ternaryfunc>,
    pub nb_inplace_lshift: Option<binaryfunc>,
    pub nb_inplace_rshift: Option<binaryfunc>,
    pub nb_inplace_and: Option<binaryfunc>,
    pub nb_inplace_xor: Option<binaryfunc>,
    pub nb_inplace_or: Option<binaryfunc>,
    pub nb_floor_divide: Option<binaryfunc>,
    pub nb_true_divide: Option<binaryfunc>,
    pub nb_inplace_floor_divide: Option<binaryfunc>,
    pub nb_inplace_true_divide: Option<binaryfunc>,
    pub nb_index: Option<unaryfunc>,
}

impl Clone for PyNumberMethods {
    #[inline]
    fn clone(&self) -> PyNumberMethods {
        *self
    }
}

pub const PyNumberMethods_INIT: PyNumberMethods = PyNumberMethods {
    nb_add: None,
    nb_subtract: None,
    nb_multiply: None,
    nb_divide: None,
    nb_remainder: None,
    nb_divmod: None,
    nb_power: None,
    nb_negative: None,
    nb_positive: None,
    nb_absolute: None,
    nb_nonzero: None,
    nb_invert: None,
    nb_lshift: None,
    nb_rshift: None,
    nb_and: None,
    nb_xor: None,
    nb_or: None,
    nb_coerce: None,
    nb_c_int: None,
    nb_long: None,
    nb_float: None,
    nb_oct: None,
    nb_hex: None,
    nb_inplace_add: None,
    nb_inplace_subtract: None,
    nb_inplace_multiply: None,
    nb_inplace_divide: None,
    nb_inplace_remainder: None,
    nb_inplace_power: None,
    nb_inplace_lshift: None,
    nb_inplace_rshift: None,
    nb_inplace_and: None,
    nb_inplace_xor: None,
    nb_inplace_or: None,
    nb_floor_divide: None,
    nb_true_divide: None,
    nb_inplace_floor_divide: None,
    nb_inplace_true_divide: None,
    nb_index: None,
};

#[repr(C)]
#[derive(Copy)]
pub struct PySequenceMethods {
    pub sq_length: Option<lenfunc>,
    pub sq_concat: Option<binaryfunc>,
    pub sq_repeat: Option<ssizeargfunc>,
    pub sq_item: Option<ssizeargfunc>,
    pub sq_slice: Option<ssizessizeargfunc>,
    pub sq_ass_item: Option<ssizeobjargproc>,
    pub sq_ass_slice: Option<ssizessizeobjargproc>,
    pub sq_contains: Option<objobjproc>,
    pub sq_inplace_concat: Option<binaryfunc>,
    pub sq_inplace_repeat: Option<ssizeargfunc>,
}

impl Clone for PySequenceMethods {
    #[inline]
    fn clone(&self) -> PySequenceMethods {
        *self
    }
}

pub const PySequenceMethods_INIT: PySequenceMethods = PySequenceMethods {
    sq_length: None,
    sq_concat: None,
    sq_repeat: None,
    sq_item: None,
    sq_slice: None,
    sq_ass_item: None,
    sq_ass_slice: None,
    sq_contains: None,
    sq_inplace_concat: None,
    sq_inplace_repeat: None,
};

#[repr(C)]
#[derive(Copy)]
pub struct PyMappingMethods {
    pub mp_length: Option<lenfunc>,
    pub mp_subscript: Option<binaryfunc>,
    pub mp_ass_subscript: Option<objobjargproc>,
}

impl Clone for PyMappingMethods {
    #[inline]
    fn clone(&self) -> PyMappingMethods {
        *self
    }
}

pub const PyMappingMethods_INIT: PyMappingMethods = PyMappingMethods {
    mp_length: None,
    mp_subscript: None,
    mp_ass_subscript: None,
};

#[repr(C)]
#[derive(Copy)]
pub struct PyBufferProcs {
    pub bf_getreadbuffer: Option<readbufferproc>,
    pub bf_getwritebuffer: Option<writebufferproc>,
    pub bf_getsegcount: Option<segcountproc>,
    pub bf_getcharbuffer: Option<charbufferproc>,
    pub bf_getbuffer: Option<getbufferproc>,
    pub bf_releasebuffer: Option<releasebufferproc>,
}

impl Clone for PyBufferProcs {
    #[inline]
    fn clone(&self) -> PyBufferProcs {
        *self
    }
}

pub const PyBufferProcs_INIT: PyBufferProcs = PyBufferProcs {
    bf_getreadbuffer: None,
    bf_getwritebuffer: None,
    bf_getsegcount: None,
    bf_getcharbuffer: None,
    bf_getbuffer: None,
    bf_releasebuffer: None,
};

pub type freefunc = unsafe extern "C" fn(arg1: *mut c_void);
pub type destructor = unsafe extern "C" fn(arg1: *mut PyObject);
pub type printfunc =
    unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut FILE, arg3: c_int) -> c_int;
pub type getattrfunc =
    unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut c_char) -> *mut PyObject;
pub type getattrofunc =
    unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject;
pub type setattrfunc =
    unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut c_char, arg3: *mut PyObject) -> c_int;
pub type setattrofunc =
    unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject) -> c_int;
pub type cmpfunc = unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> c_int;
pub type reprfunc = unsafe extern "C" fn(arg1: *mut PyObject) -> *mut PyObject;
pub type hashfunc = unsafe extern "C" fn(arg1: *mut PyObject) -> c_long;
pub type richcmpfunc =
    unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject, arg3: c_int) -> *mut PyObject;
pub type getiterfunc = unsafe extern "C" fn(arg1: *mut PyObject) -> *mut PyObject;
pub type iternextfunc = unsafe extern "C" fn(arg1: *mut PyObject) -> *mut PyObject;
pub type descrgetfunc = unsafe extern "C" fn(
    arg1: *mut PyObject,
    arg2: *mut PyObject,
    arg3: *mut PyObject,
) -> *mut PyObject;
pub type descrsetfunc =
    unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject) -> c_int;
pub type initproc =
    unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject) -> c_int;
pub type newfunc = unsafe extern "C" fn(
    arg1: *mut PyTypeObject,
    arg2: *mut PyObject,
    arg3: *mut PyObject,
) -> *mut PyObject;
pub type allocfunc =
    unsafe extern "C" fn(arg1: *mut PyTypeObject, arg2: Py_ssize_t) -> *mut PyObject;

#[repr(C)]
#[derive(Copy)]
pub struct PyTypeObject {
    #[cfg(py_sys_config = "Py_TRACE_REFS")]
    pub _ob_next: *mut PyObject,
    #[cfg(py_sys_config = "Py_TRACE_REFS")]
    pub _ob_prev: *mut PyObject,
    pub ob_refcnt: Py_ssize_t,
    pub ob_type: *mut PyTypeObject,
    pub ob_size: Py_ssize_t,
    pub tp_name: *const c_char,
    pub tp_basicsize: Py_ssize_t,
    pub tp_itemsize: Py_ssize_t,
    pub tp_dealloc: Option<destructor>,
    pub tp_print: Option<printfunc>,
    pub tp_getattr: Option<getattrfunc>,
    pub tp_setattr: Option<setattrfunc>,
    pub tp_compare: Option<cmpfunc>,
    pub tp_repr: Option<reprfunc>,
    pub tp_as_number: *mut PyNumberMethods,
    pub tp_as_sequence: *mut PySequenceMethods,
    pub tp_as_mapping: *mut PyMappingMethods,
    pub tp_hash: Option<hashfunc>,
    pub tp_call: Option<ternaryfunc>,
    pub tp_str: Option<reprfunc>,
    pub tp_getattro: Option<getattrofunc>,
    pub tp_setattro: Option<setattrofunc>,
    pub tp_as_buffer: *mut PyBufferProcs,
    pub tp_flags: c_long,
    pub tp_doc: *const c_char,
    pub tp_traverse: Option<traverseproc>,
    pub tp_clear: Option<inquiry>,
    pub tp_richcompare: Option<richcmpfunc>,
    pub tp_weaklistoffset: Py_ssize_t,
    pub tp_iter: Option<getiterfunc>,
    pub tp_iternext: Option<iternextfunc>,
    pub tp_methods: *mut PyMethodDef,
    pub tp_members: *mut crate::structmember::PyMemberDef,
    pub tp_getset: *mut crate::descrobject::PyGetSetDef,
    pub tp_base: *mut PyTypeObject,
    pub tp_dict: *mut PyObject,
    pub tp_descr_get: Option<descrgetfunc>,
    pub tp_descr_set: Option<descrsetfunc>,
    pub tp_dictoffset: Py_ssize_t,
    pub tp_init: Option<initproc>,
    pub tp_alloc: Option<allocfunc>,
    pub tp_new: Option<newfunc>,
    pub tp_free: Option<freefunc>,
    pub tp_is_gc: Option<inquiry>,
    pub tp_bases: *mut PyObject,
    pub tp_mro: *mut PyObject,
    pub tp_cache: *mut PyObject,
    pub tp_subclasses: *mut PyObject,
    pub tp_weaklist: *mut PyObject,
    pub tp_del: Option<destructor>,
    pub tp_version_tag: c_uint,
    #[cfg(py_sys_config = "COUNT_ALLOCS")]
    pub tp_allocs: Py_ssize_t,
    #[cfg(py_sys_config = "COUNT_ALLOCS")]
    pub tp_frees: Py_ssize_t,
    #[cfg(py_sys_config = "COUNT_ALLOCS")]
    pub tp_maxalloc: Py_ssize_t,
    #[cfg(py_sys_config = "COUNT_ALLOCS")]
    pub tp_prev: *mut PyTypeObject,
    #[cfg(py_sys_config = "COUNT_ALLOCS")]
    pub tp_next: *mut PyTypeObject,
}

impl Clone for PyTypeObject {
    #[inline]
    fn clone(&self) -> PyTypeObject {
        *self
    }
}

#[cfg(py_sys_config = "Py_TRACE_REFS")]
pub const PyTypeObject_INIT: PyTypeObject = PyTypeObject {
    _ob_next: 0 as *mut PyObject,
    _ob_prev: 0 as *mut PyObject,
    ob_refcnt: 1,
    ob_type: 0 as *mut PyTypeObject,
    ob_size: 0,
    tp_name: 0 as *const c_char,
    tp_basicsize: 0,
    tp_itemsize: 0,
    tp_dealloc: None,
    tp_print: None,
    tp_getattr: None,
    tp_setattr: None,
    tp_compare: None,
    tp_repr: None,
    tp_as_number: 0 as *mut PyNumberMethods,
    tp_as_sequence: 0 as *mut PySequenceMethods,
    tp_as_mapping: 0 as *mut PyMappingMethods,
    tp_hash: None,
    tp_call: None,
    tp_str: None,
    tp_getattro: None,
    tp_setattro: None,
    tp_as_buffer: 0 as *mut PyBufferProcs,
    tp_flags: Py_TPFLAGS_DEFAULT,
    tp_doc: 0 as *const c_char,
    tp_traverse: None,
    tp_clear: None,
    tp_richcompare: None,
    tp_weaklistoffset: 0,
    tp_iter: None,
    tp_iternext: None,
    tp_methods: 0 as *mut PyMethodDef,
    tp_members: 0 as *mut crate::structmember::PyMemberDef,
    tp_getset: 0 as *mut crate::descrobject::PyGetSetDef,
    tp_base: 0 as *mut PyTypeObject,
    tp_dict: 0 as *mut PyObject,
    tp_descr_get: None,
    tp_descr_set: None,
    tp_dictoffset: 0,
    tp_init: None,
    tp_alloc: None,
    tp_new: None,
    tp_free: None,
    tp_is_gc: None,
    tp_bases: 0 as *mut PyObject,
    tp_mro: 0 as *mut PyObject,
    tp_cache: 0 as *mut PyObject,
    tp_subclasses: 0 as *mut PyObject,
    tp_weaklist: 0 as *mut PyObject,
    tp_del: None,
    tp_version_tag: 0,
};

#[cfg(not(py_sys_config = "Py_TRACE_REFS"))]
pub const PyTypeObject_INIT: PyTypeObject = PyTypeObject {
    ob_refcnt: 1,
    ob_type: 0 as *mut PyTypeObject,
    ob_size: 0,
    tp_name: 0 as *const c_char,
    tp_basicsize: 0,
    tp_itemsize: 0,
    tp_dealloc: None,
    tp_print: None,
    tp_getattr: None,
    tp_setattr: None,
    tp_compare: None,
    tp_repr: None,
    tp_as_number: 0 as *mut PyNumberMethods,
    tp_as_sequence: 0 as *mut PySequenceMethods,
    tp_as_mapping: 0 as *mut PyMappingMethods,
    tp_hash: None,
    tp_call: None,
    tp_str: None,
    tp_getattro: None,
    tp_setattro: None,
    tp_as_buffer: 0 as *mut PyBufferProcs,
    tp_flags: Py_TPFLAGS_DEFAULT,
    tp_doc: 0 as *const c_char,
    tp_traverse: None,
    tp_clear: None,
    tp_richcompare: None,
    tp_weaklistoffset: 0,
    tp_iter: None,
    tp_iternext: None,
    tp_methods: 0 as *mut PyMethodDef,
    tp_members: 0 as *mut crate::structmember::PyMemberDef,
    tp_getset: 0 as *mut crate::descrobject::PyGetSetDef,
    tp_base: 0 as *mut PyTypeObject,
    tp_dict: 0 as *mut PyObject,
    tp_descr_get: None,
    tp_descr_set: None,
    tp_dictoffset: 0,
    tp_init: None,
    tp_alloc: None,
    tp_new: None,
    tp_free: None,
    tp_is_gc: None,
    tp_bases: 0 as *mut PyObject,
    tp_mro: 0 as *mut PyObject,
    tp_cache: 0 as *mut PyObject,
    tp_subclasses: 0 as *mut PyObject,
    tp_weaklist: 0 as *mut PyObject,
    tp_del: None,
    tp_version_tag: 0,
};

impl PyTypeObject {
    #[inline]
    pub fn init_ob_type(&mut self, type_object: *mut PyTypeObject) {
        self.ob_type = type_object;
    }
}

#[repr(C)]
#[derive(Copy)]
pub struct PyHeapTypeObject {
    pub ht_type: PyTypeObject,
    pub as_number: PyNumberMethods,
    pub as_mapping: PyMappingMethods,
    pub as_sequence: PySequenceMethods,
    pub as_buffer: PyBufferProcs,
    pub ht_name: *mut PyObject,
    pub ht_slots: *mut PyObject,
}

impl Clone for PyHeapTypeObject {
    #[inline]
    fn clone(&self) -> PyHeapTypeObject {
        *self
    }
}

// access macro to the members which are floating "behind" the object
#[inline]
pub unsafe fn PyHeapType_GET_MEMBERS(
    etype: *mut PyHeapTypeObject,
) -> *mut crate::structmember::PyMemberDef {
    let basicsize = (*Py_TYPE(etype as *mut PyObject)).tp_basicsize;
    (etype as *mut u8).offset(basicsize as isize) as *mut crate::structmember::PyMemberDef
}

#[cfg_attr(windows, link(name = "pythonXY"))]
extern "C" {
    pub fn PyType_IsSubtype(a: *mut PyTypeObject, b: *mut PyTypeObject) -> c_int;
}

#[inline(always)]
pub unsafe fn PyObject_TypeCheck(ob: *mut PyObject, tp: *mut PyTypeObject) -> c_int {
    (Py_TYPE(ob) == tp || PyType_IsSubtype(Py_TYPE(ob), tp) != 0) as c_int
}

#[cfg_attr(windows, link(name = "pythonXY"))]
extern "C" {
    pub static mut PyType_Type: PyTypeObject;
    pub static mut PyBaseObject_Type: PyTypeObject;
    pub static mut PySuper_Type: PyTypeObject;
}

#[inline(always)]
pub unsafe fn PyType_Check(op: *mut PyObject) -> c_int {
    PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_TYPE_SUBCLASS)
}

#[inline(always)]
pub unsafe fn PyType_CheckExact(op: *mut PyObject) -> c_int {
    (Py_TYPE(op) == (&mut PyType_Type as *mut _)) as c_int
}

#[cfg_attr(windows, link(name = "pythonXY"))]
extern "C" {
    pub fn PyType_Ready(t: *mut PyTypeObject) -> c_int;
    pub fn PyType_GenericAlloc(t: *mut PyTypeObject, nitems: Py_ssize_t) -> *mut PyObject;
    pub fn PyType_GenericNew(
        t: *mut PyTypeObject,
        args: *mut PyObject,
        kwds: *mut PyObject,
    ) -> *mut PyObject;
    fn _PyType_Lookup(arg1: *mut PyTypeObject, arg2: *mut PyObject) -> *mut PyObject;
    fn _PyObject_LookupSpecial(
        arg1: *mut PyObject,
        arg2: *mut c_char,
        arg3: *mut *mut PyObject,
    ) -> *mut PyObject;
    pub fn PyType_ClearCache() -> c_uint;
    pub fn PyType_Modified(t: *mut PyTypeObject);

    pub fn PyObject_Print(o: *mut PyObject, fp: *mut FILE, flags: c_int) -> c_int;
    fn _PyObject_Dump(o: *mut PyObject);
    pub fn PyObject_Repr(o: *mut PyObject) -> *mut PyObject;
    fn _PyObject_Str(o: *mut PyObject) -> *mut PyObject;
    pub fn PyObject_Str(o: *mut PyObject) -> *mut PyObject;
}

#[inline(always)]
pub unsafe fn PyObject_Bytes(o: *mut PyObject) -> *mut PyObject {
    PyObject_Str(o)
}

#[cfg_attr(windows, link(name = "pythonXY"))]
extern "C" {
    #[cfg(py_sys_config = "Py_USING_UNICODE")]
    pub fn PyObject_Unicode(o: *mut PyObject) -> *mut PyObject;

    pub fn PyObject_Compare(arg1: *mut PyObject, arg2: *mut PyObject) -> c_int;
    pub fn PyObject_RichCompare(
        arg1: *mut PyObject,
        arg2: *mut PyObject,
        arg3: c_int,
    ) -> *mut PyObject;
    pub fn PyObject_RichCompareBool(arg1: *mut PyObject, arg2: *mut PyObject, arg3: c_int)
        -> c_int;
    pub fn PyObject_GetAttrString(arg1: *mut PyObject, arg2: *const c_char) -> *mut PyObject;
    pub fn PyObject_SetAttrString(
        arg1: *mut PyObject,
        arg2: *const c_char,
        arg3: *mut PyObject,
    ) -> c_int;
    pub fn PyObject_HasAttrString(arg1: *mut PyObject, arg2: *const c_char) -> c_int;
    pub fn PyObject_GetAttr(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject;
    pub fn PyObject_SetAttr(arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject)
        -> c_int;
    pub fn PyObject_HasAttr(arg1: *mut PyObject, arg2: *mut PyObject) -> c_int;
    fn _PyObject_GetDictPtr(arg1: *mut PyObject) -> *mut *mut PyObject;
    pub fn PyObject_SelfIter(arg1: *mut PyObject) -> *mut PyObject;
    pub fn PyObject_GenericGetAttr(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject;
    pub fn PyObject_GenericSetAttr(
        arg1: *mut PyObject,
        arg2: *mut PyObject,
        arg3: *mut PyObject,
    ) -> c_int;
    pub fn PyObject_Hash(arg1: *mut PyObject) -> c_long;
    pub fn PyObject_HashNotImplemented(arg1: *mut PyObject) -> c_long;
    pub fn PyObject_IsTrue(arg1: *mut PyObject) -> c_int;
    pub fn PyObject_Not(arg1: *mut PyObject) -> c_int;
    pub fn PyCallable_Check(arg1: *mut PyObject) -> c_int;
    pub fn PyNumber_Coerce(arg1: *mut *mut PyObject, arg2: *mut *mut PyObject) -> c_int;
    pub fn PyNumber_CoerceEx(arg1: *mut *mut PyObject, arg2: *mut *mut PyObject) -> c_int;
    pub fn PyObject_ClearWeakRefs(arg1: *mut PyObject);
    fn _PyObject_SlotCompare(arg1: *mut PyObject, arg2: *mut PyObject) -> c_int;
    fn _PyObject_GenericGetAttrWithDict(
        arg1: *mut PyObject,
        arg2: *mut PyObject,
        arg3: *mut PyObject,
    ) -> *mut PyObject;
    fn _PyObject_GenericSetAttrWithDict(
        arg1: *mut PyObject,
        arg2: *mut PyObject,
        arg3: *mut PyObject,
        arg4: *mut PyObject,
    ) -> c_int;
    pub fn PyObject_Dir(arg1: *mut PyObject) -> *mut PyObject;
    pub fn Py_ReprEnter(arg1: *mut PyObject) -> c_int;
    pub fn Py_ReprLeave(arg1: *mut PyObject);
    fn _Py_HashDouble(arg1: c_double) -> c_long;
    fn _Py_HashPointer(arg1: *mut c_void) -> c_long;
}

// Flag bits for printing:
pub const Py_PRINT_RAW: c_int = 1; // No string quotes etc.

/// PyBufferProcs contains bf_getcharbuffer
pub const Py_TPFLAGS_HAVE_GETCHARBUFFER: c_long = (1 << 0);

/// PySequenceMethods contains sq_contains
pub const Py_TPFLAGS_HAVE_SEQUENCE_IN: c_long = (1 << 1);

/// PySequenceMethods and PyNumberMethods contain in-place operators
pub const Py_TPFLAGS_HAVE_INPLACEOPS: c_long = (1 << 3);

/// PyNumberMethods do their own coercion
pub const Py_TPFLAGS_CHECKTYPES: c_long = (1 << 4);

/// tp_richcompare is defined
pub const Py_TPFLAGS_HAVE_RICHCOMPARE: c_long = (1 << 5);

/// Objects which are weakly referencable if their tp_weaklistoffset is >0
pub const Py_TPFLAGS_HAVE_WEAKREFS: c_long = (1 << 6);

/// tp_iter is defined
pub const Py_TPFLAGS_HAVE_ITER: c_long = (1 << 7);

/// New members introduced by Python 2.2 exist
pub const Py_TPFLAGS_HAVE_CLASS: c_long = (1 << 8);

/// Set if the type object is dynamically allocated
pub const Py_TPFLAGS_HEAPTYPE: c_long = (1 << 9);

/// Set if the type allows subclassing
pub const Py_TPFLAGS_BASETYPE: c_long = (1 << 10);

/// Set if the type is 'ready' -- fully initialized
pub const Py_TPFLAGS_READY: c_long = (1 << 12);

/// Set while the type is being 'readied', to prevent recursive ready calls
pub const Py_TPFLAGS_READYING: c_long = (1 << 13);

/// Objects support garbage collection (see objimp.h)
pub const Py_TPFLAGS_HAVE_GC: c_long = (1 << 14);

// Two bits are preserved for Stackless Python, next after this is 17.
const Py_TPFLAGS_HAVE_STACKLESS_EXTENSION: c_long = 0;

/// Objects support nb_index in PyNumberMethods
pub const Py_TPFLAGS_HAVE_INDEX: c_long = (1 << 17);

/// Objects support type attribute cache
pub const Py_TPFLAGS_HAVE_VERSION_TAG: c_long = (1 << 18);
pub const Py_TPFLAGS_VALID_VERSION_TAG: c_long = (1 << 19);

/* Type is abstract and cannot be instantiated */
pub const Py_TPFLAGS_IS_ABSTRACT: c_long = (1 << 20);

/* Has the new buffer protocol */
pub const Py_TPFLAGS_HAVE_NEWBUFFER: c_long = (1 << 21);

/* These flags are used to determine if a type is a subclass. */
pub const Py_TPFLAGS_INT_SUBCLASS: c_long = (1 << 23);
pub const Py_TPFLAGS_LONG_SUBCLASS: c_long = (1 << 24);
pub const Py_TPFLAGS_LIST_SUBCLASS: c_long = (1 << 25);
pub const Py_TPFLAGS_TUPLE_SUBCLASS: c_long = (1 << 26);
pub const Py_TPFLAGS_STRING_SUBCLASS: c_long = (1 << 27);
pub const Py_TPFLAGS_UNICODE_SUBCLASS: c_long = (1 << 28);
pub const Py_TPFLAGS_DICT_SUBCLASS: c_long = (1 << 29);
pub const Py_TPFLAGS_BASE_EXC_SUBCLASS: c_long = (1 << 30);
pub const Py_TPFLAGS_TYPE_SUBCLASS: c_long = (1 << 31);

pub const Py_TPFLAGS_DEFAULT: c_long = (Py_TPFLAGS_HAVE_GETCHARBUFFER
    | Py_TPFLAGS_HAVE_SEQUENCE_IN
    | Py_TPFLAGS_HAVE_INPLACEOPS
    | Py_TPFLAGS_HAVE_RICHCOMPARE
    | Py_TPFLAGS_HAVE_WEAKREFS
    | Py_TPFLAGS_HAVE_ITER
    | Py_TPFLAGS_HAVE_CLASS
    | Py_TPFLAGS_HAVE_STACKLESS_EXTENSION
    | Py_TPFLAGS_HAVE_INDEX
    | 0);

#[inline(always)]
pub unsafe fn PyType_HasFeature(t: *mut PyTypeObject, f: c_long) -> c_int {
    (((*t).tp_flags & f) != 0) as c_int
}

#[inline(always)]
pub unsafe fn PyType_FastSubclass(t: *mut PyTypeObject, f: c_long) -> c_int {
    PyType_HasFeature(t, f)
}

// Reference counting macros.
#[inline(always)]
pub unsafe fn Py_INCREF(op: *mut PyObject) {
    if cfg!(py_sys_config = "Py_REF_DEBUG") {
        Py_IncRef(op)
    } else {
        (*op).ob_refcnt += 1
    }
}

#[inline(always)]
pub unsafe fn Py_DECREF(op: *mut PyObject) {
    if cfg!(py_sys_config = "Py_REF_DEBUG") || cfg!(py_sys_config = "COUNT_ALLOCS") {
        Py_DecRef(op)
    } else {
        (*op).ob_refcnt -= 1;
        if (*op).ob_refcnt == 0 {
            (*Py_TYPE(op)).tp_dealloc.unwrap()(op)
        }
    }
}

#[inline(always)]
pub unsafe fn Py_CLEAR(op: &mut *mut PyObject) {
    let tmp = *op;
    if !tmp.is_null() {
        *op = ptr::null_mut();
        Py_DECREF(tmp);
    }
}

#[inline(always)]
pub unsafe fn Py_XINCREF(op: *mut PyObject) {
    if !op.is_null() {
        Py_INCREF(op)
    }
}

#[inline(always)]
pub unsafe fn Py_XDECREF(op: *mut PyObject) {
    if !op.is_null() {
        Py_DECREF(op)
    }
}

#[cfg_attr(windows, link(name = "pythonXY"))]
extern "C" {
    pub fn Py_IncRef(o: *mut PyObject);
    pub fn Py_DecRef(o: *mut PyObject);

    static mut _Py_NoneStruct: PyObject;
    static mut _Py_NotImplementedStruct: PyObject;
}

#[inline(always)]
pub unsafe fn Py_None() -> *mut PyObject {
    &mut _Py_NoneStruct
}

#[inline(always)]
pub unsafe fn Py_NotImplemented() -> *mut PyObject {
    &mut _Py_NotImplementedStruct
}

/* Rich comparison opcodes */
pub const Py_LT: c_int = 0;
pub const Py_LE: c_int = 1;
pub const Py_EQ: c_int = 2;
pub const Py_NE: c_int = 3;
pub const Py_GT: c_int = 4;
pub const Py_GE: c_int = 5;

#[cfg_attr(windows, link(name = "pythonXY"))]
extern "C" {
    fn _PyTrash_thread_deposit_object(o: *mut PyObject);
    fn _PyTrash_thread_destroy_chain();
}

pub const PyTrash_UNWIND_LEVEL: c_int = 50;

#[inline(always)]
pub unsafe fn Py_TRASHCAN<F: FnOnce() -> ()>(op: *mut PyObject, body: F) {
    let tstate = crate::pystate::PyThreadState_GET();
    if tstate.is_null() || (*tstate).trash_delete_nesting < PyTrash_UNWIND_LEVEL {
        if !tstate.is_null() {
            (*tstate).trash_delete_nesting += 1;
        }
        body();
        if !tstate.is_null() {
            (*tstate).trash_delete_nesting -= 1;
            if !(*tstate).trash_delete_later.is_null() && (*tstate).trash_delete_nesting <= 0 {
                _PyTrash_thread_destroy_chain();
            }
        }
    } else {
        _PyTrash_thread_deposit_object(op)
    }
}