#define Py_LIMITED_API 0x030f0000

#include "parts.h"

PyABIInfo_VAR(abi_info);

/* Define a bunch of (mostly nonsensical) functions to put in slots, so
 * Lib/test/test_capi/test_slots.py can verify they've been assigned to
 * the right slots.

 * This module is full of "magic constants" which simply need to match
 * between the C and Python part of the tests.
 */

// getbufferproc: export buffer; increment a counter
static int
demo_getbuffer(PyObject *exporter, Py_buffer *view, int flags)
{
    Py_INCREF(exporter);
    // PyObject_GetTypeData & Py_TYPE: safe on non-subclassable type
    int *data = PyObject_GetTypeData(exporter, Py_TYPE(exporter));
    if (!data) {
        return -1;
    }
    (*data)++;
    return PyBuffer_FillInfo(view, exporter, "buf", 4, 1, flags);
}

// releasebufferproc: release buffer; decrement a counter
static void
demo_releasebuffer(PyObject *exporter, Py_buffer *view)
{
    Py_DECREF(exporter);
    // PyObject_GetTypeData & Py_TYPE: safe on non-subclassable type
    int *data = PyObject_GetTypeData(exporter, Py_TYPE(exporter));
    if (!data) {
        PyErr_WriteUnraisable(exporter);
        return;
    }
    (*data)--;
    return;
}

// objobjargproc: raise KeyError
static int
demo_ass_subscript(PyObject *o, PyObject *key, PyObject *v)
{
    PyErr_Format(PyExc_KeyError, "I don't like that key");
    return -1;
}

// lenfunc: report 456
static Py_ssize_t
demo_length(PyObject *o)
{
    return (Py_ssize_t)456;
}

// binaryfunc; return constant value
static PyObject *binop_123(PyObject* a, PyObject *b) { return PyLong_FromLong(123); }
static PyObject *binop_234(PyObject* a, PyObject *b) { return PyLong_FromLong(234); }
static PyObject *binop_345(PyObject* a, PyObject *b) { return PyLong_FromLong(345); }
static PyObject *binop_456(PyObject* a, PyObject *b) { return PyLong_FromLong(456); }
static PyObject *binop_567(PyObject* a, PyObject *b) { return PyLong_FromLong(567); }
static PyObject *binop_678(PyObject* a, PyObject *b) { return PyLong_FromLong(678); }

static PyObject *
type_from_slots(PyObject* module, PyObject *args)
{
    char *case_name;
    if (!PyArg_ParseTuple(args, "s", &case_name)) {
        return NULL;
    }
#define CASE(NAME)                                                          \
    if (strcmp(case_name, NAME) == 0) {                                     \
        return PyType_FromSlots((PySlot[]) {                                \
            PySlot_DATA(Py_tp_name, "_testlimitedcapi.MyType"),             \
            PySlot_DATA(Py_tp_module, module),                              \
    /////////////////////////////////////////////////////////////////////////
#define ENDCASE()                                                           \
            PySlot_END                                                      \
        });                                                                 \
    }                                                                       \
    /////////////////////////////////////////////////////////////////////////

    CASE("basic")
    ENDCASE()
    CASE("foreign_slot")
        PySlot_DATA(Py_mod_name, "this is not a module"),
    ENDCASE()
    CASE("basicsize")
        PySlot_SIZE(Py_tp_basicsize, 256),
    ENDCASE()
    CASE("extra_basicsize")
        PySlot_SIZE(Py_tp_extra_basicsize, 256),
    ENDCASE()
    CASE("itemsize")
        PySlot_SIZE(Py_tp_itemsize, 16),
    ENDCASE()
    CASE("flags")
        PySlot_UINT64(Py_tp_flags,
                      Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_BASETYPE),
    ENDCASE()
    CASE("matmul_123")
        PySlot_FUNC(Py_nb_matrix_multiply, binop_123),
    ENDCASE()
    CASE("optional_end")
        {.sl_flags=PySlot_OPTIONAL},
    ENDCASE()
    CASE("invalid")
        {.sl_id=Py_slot_invalid},
    ENDCASE()
    CASE("invalid_fbad")
        {.sl_id=0xfbad},
    ENDCASE()
    CASE("optional_invalid")
        {.sl_id=Py_slot_invalid, .sl_flags=PySlot_OPTIONAL},
        PySlot_SIZE(Py_tp_extra_basicsize, 256),
    ENDCASE()
    CASE("optional_invalid_fbad")
        {.sl_id=0xfbad, .sl_flags=PySlot_OPTIONAL},
        PySlot_SIZE(Py_tp_extra_basicsize, 256),
    ENDCASE()
    CASE("old_slot_numbers")
        PySlot_FUNC(1, demo_getbuffer),
        PySlot_FUNC(2, demo_releasebuffer),
        PySlot_FUNC(3, demo_ass_subscript),
        PySlot_FUNC(4, demo_length),
        PySlot_SIZE(Py_tp_extra_basicsize, sizeof(int)),
        PySlot_STATIC_DATA(Py_tp_members, ((PyMemberDef[]) {
            {"buf_counter", Py_T_INT, 0, Py_READONLY | Py_RELATIVE_OFFSET},
            {NULL},
        })),
    ENDCASE()
    CASE("new_slot_numbers")
        PySlot_FUNC(88, demo_getbuffer),
        PySlot_FUNC(89, demo_releasebuffer),
        PySlot_FUNC(90, demo_ass_subscript),
        PySlot_FUNC(91, demo_length),
        PySlot_SIZE(Py_tp_extra_basicsize, sizeof(int)),
        PySlot_STATIC_DATA(Py_tp_members, ((PyMemberDef[]) {
            {"buf_counter", Py_T_INT, 0, Py_READONLY | Py_RELATIVE_OFFSET},
            {NULL},
        })),
    ENDCASE()
    CASE("nonstatic_tp_members")
        PySlot_SIZE(Py_tp_extra_basicsize, sizeof(int)),
        PySlot_DATA(Py_tp_members, ((PyMemberDef[]) {
            {"buf_counter", Py_T_INT, 0, Py_READONLY | Py_RELATIVE_OFFSET},
            {NULL},
        })),
    ENDCASE()
    CASE("intptr_flags_macro")
        PySlot_PTR(Py_tp_flags, (void*)(intptr_t)Py_TPFLAGS_IMMUTABLETYPE),
    ENDCASE()
    CASE("intptr_flags_struct")
        {.sl_id=Py_tp_flags,
         .sl_flags=PySlot_INTPTR,
         .sl_ptr=(void*)(intptr_t)Py_TPFLAGS_IMMUTABLETYPE,
         },
    ENDCASE()
    CASE("intptr_static")
        PySlot_SIZE(Py_tp_extra_basicsize, sizeof(int)),
        PySlot_PTR_STATIC(Py_tp_members, ((PyMemberDef[]) {
            {"attribute", Py_T_INT, 0, Py_READONLY | Py_RELATIVE_OFFSET},
            {NULL},
        })),
    ENDCASE()
    CASE("nested")
        PySlot_FUNC(Py_nb_add, binop_123),
        PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
            PySlot_FUNC(Py_nb_subtract, binop_234),
            PySlot_END,
        })),
    ENDCASE()
    CASE("nested_max")
        PySlot_FUNC(Py_nb_add, binop_123),
        PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
            PySlot_FUNC(Py_nb_subtract, binop_234),
            PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
                PySlot_FUNC(Py_nb_multiply, binop_345),
                PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
                    PySlot_FUNC(Py_nb_true_divide, binop_456),
                    PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
                        PySlot_FUNC(Py_nb_remainder, binop_567),
                        PySlot_END
                    })),
                    PySlot_END,
                })),
                PySlot_END,
            })),
            PySlot_END,
        })),
    ENDCASE()
    CASE("nested_over_limit")
        PySlot_FUNC(Py_nb_add, binop_123),
        PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
            PySlot_FUNC(Py_nb_subtract, binop_234),
            PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
                PySlot_FUNC(Py_nb_multiply, binop_345),
                PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
                    PySlot_FUNC(Py_nb_true_divide, binop_456),
                    PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
                        PySlot_FUNC(Py_nb_remainder, binop_567),
                        PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
                            PySlot_FUNC(Py_nb_xor, binop_678),
                            PySlot_END
                        })),
                        PySlot_END
                    })),
                    PySlot_END,
                })),
                PySlot_END,
            })),
            PySlot_END,
        })),
    ENDCASE()
    CASE("nested_old")
        PySlot_FUNC(Py_nb_add, binop_123),
        PySlot_DATA(Py_tp_slots, ((PyType_Slot[]) {
            {Py_nb_subtract, binop_234},
            {0},
        })),
    ENDCASE()
    CASE("nested_old_max")
        PySlot_FUNC(Py_nb_add, binop_123),
        PySlot_DATA(Py_tp_slots, ((PyType_Slot[]) {
            {Py_nb_subtract, binop_234},
            {Py_tp_slots, ((PyType_Slot[]) {
                {Py_nb_multiply, binop_345},
                {Py_tp_slots, ((PyType_Slot[]) {
                    {Py_nb_true_divide, binop_456},
                    {Py_tp_slots, ((PyType_Slot[]) {
                        {Py_nb_remainder, binop_567},
                        {0},
                    })},
                    {0},
                })},
                {0},
            })},
            {0},
        })),
    ENDCASE()
    CASE("nested_old_over_limit")
        PySlot_FUNC(Py_nb_add, binop_123),
        PySlot_DATA(Py_tp_slots, ((PyType_Slot[]) {
            {Py_nb_subtract, binop_234},
            {Py_tp_slots, ((PyType_Slot[]) {
                {Py_nb_multiply, binop_345},
                {Py_tp_slots, ((PyType_Slot[]) {
                    {Py_nb_true_divide, binop_456},
                    {Py_tp_slots, ((PyType_Slot[]) {
                        {Py_nb_remainder, binop_567},
                        {Py_tp_slots, ((PyType_Slot[]) {
                            {Py_nb_xor, binop_678},
                            {0},
                        })},
                        {0},
                    })},
                    {0},
                })},
                {0},
            })},
            {0},
        })),
    ENDCASE()
    CASE("nested_pingpong")
        PySlot_FUNC(Py_nb_add, binop_123),
        PySlot_DATA(Py_tp_slots, ((PyType_Slot[]) {
            {Py_nb_subtract, binop_234},
            {Py_slot_subslots, ((PySlot[]) {
                PySlot_FUNC(Py_nb_multiply, binop_345),
                PySlot_DATA(Py_tp_slots, ((PyType_Slot[]) {
                    {Py_nb_true_divide, binop_456},
                    {Py_slot_subslots, ((PySlot[]) {
                        PySlot_FUNC(Py_nb_remainder, binop_567),
                        PySlot_END
                    })},
                    {0},
                })),
                PySlot_END,
            })},
            {0},
        })),
    ENDCASE()
    CASE("repeat_add")
        PySlot_FUNC(Py_nb_add, binop_123),
        PySlot_FUNC(Py_nb_add, binop_456),
    ENDCASE()
    CASE("repeat_module")
        PySlot_DATA(Py_tp_module, Py_True),
        PySlot_DATA(Py_tp_module, Py_False),
    ENDCASE()

#undef CASE
#undef ENDCASE
    PyErr_Format(PyExc_SystemError, "bad case: %s", case_name);
    return NULL;
}

static PyObject *
type_from_null_slot(PyObject* module, PyObject *args)
{
    long slot_number;
    if (!PyArg_ParseTuple(args, "l", &slot_number)) {
        return NULL;
    }
    return PyType_FromSlots((PySlot[]) {
        PySlot_DATA(Py_tp_name, "_testlimitedcapi.MyType"),
        PySlot_DATA(Py_tp_module, module),
        PySlot_PTR_STATIC((uint16_t)slot_number, NULL),
        PySlot_END
    });
}

static PyObject *
type_from_null_spec_slot(PyObject* Py_UNUSED(module), PyObject *args)
{
    long slot_number;
    if (!PyArg_ParseTuple(args, "l", &slot_number)) {
        return NULL;
    }
    return PyType_FromSpec(&(PyType_Spec) {
        .name = "_testlimitedcapi.MyType",
        .slots = (PyType_Slot[]) {
            {slot_number, NULL},
            {0},
        },
    });
}

static PyObject *
demo_create(PyObject *spec, PyModuleDef *def)
{
    assert(def == NULL);
    return Py_NewRef(spec);
}

static int
demo_exec(PyObject *mod)
{
    return PyModule_AddStringConstant(mod, "exec_done", "yes");
}

static PyMethodDef *TestMethods;

static PyObject *
module_from_slots(PyObject* Py_UNUSED(module), PyObject *args)
{
    PyObject *spec;
    char *case_name;
    if (!PyArg_ParseTuple(args, "sO", &case_name, &spec)) {
        return NULL;
    }
    PyObject *mod = NULL;
#define CASE(NAME)                                                          \
    if (strcmp(case_name, NAME) == 0) {                                     \
        mod = PyModule_FromSlotsAndSpec((PySlot[]) {                        \
            PySlot_DATA(Py_mod_abi, &abi_info),                             \
            PySlot_DATA(Py_mod_gil, Py_MOD_GIL_NOT_USED),                   \
    /////////////////////////////////////////////////////////////////////////
#define ENDCASE()                                                           \
            PySlot_END                                                      \
        }, spec);                                                           \
    }                                                                       \
    /////////////////////////////////////////////////////////////////////////

    CASE("basic")
    ENDCASE()
    CASE("foreign_slot")
        PySlot_DATA(Py_tp_name, "this is not a type"),
    ENDCASE()
    CASE("state_size")
        PySlot_SIZE(Py_mod_state_size, 42),
    ENDCASE()
    CASE("multi_interp")
        PySlot_DATA(Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED),
    ENDCASE()
    CASE("exec")
        PySlot_FUNC(Py_mod_exec, demo_exec),
    ENDCASE()
    CASE("optional_end")
        {.sl_flags=PySlot_OPTIONAL},
    ENDCASE()
    CASE("invalid")
        {.sl_id=Py_slot_invalid},
    ENDCASE()
    CASE("invalid_fbad")
        {.sl_id=0xfbad},
    ENDCASE()
    CASE("optional_invalid")
        {.sl_id=Py_slot_invalid, .sl_flags=PySlot_OPTIONAL},
        PySlot_SIZE(Py_mod_exec, demo_exec),
    ENDCASE()
    CASE("optional_invalid_fbad")
        {.sl_id=0xfbad, .sl_flags=PySlot_OPTIONAL},
        PySlot_SIZE(Py_mod_exec, demo_exec),
    ENDCASE()
    CASE("old_slot_numbers")
        // 1: see old_slot_number_create case
        PySlot_FUNC(2, demo_exec),
        PySlot_DATA(3, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED),
        // 4: see module_from_gil_slot function
    ENDCASE()
    CASE("new_slot_numbers")
        // 84: see new_slot_number_create case
        PySlot_FUNC(85, demo_exec),
        PySlot_FUNC(86, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED),
        // 87: see module_from_gil_slot function
    ENDCASE()
    CASE("old_slot_number_create")
        PySlot_FUNC(1, demo_create),
    ENDCASE()
    CASE("new_slot_number_create")
        PySlot_FUNC(84, demo_create),
    ENDCASE()
    CASE("nonstatic_mod_methods")
        PySlot_DATA(Py_mod_methods, TestMethods),
    ENDCASE()
    CASE("intptr_methods")
        PySlot_PTR_STATIC(Py_mod_methods, TestMethods),
    ENDCASE()
    CASE("nested")
        PySlot_FUNC(Py_mod_exec, demo_exec),
        PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
            PySlot_DATA(Py_mod_doc, "doc"),
            PySlot_END,
        })),
    ENDCASE()
    CASE("nested_max")
        PySlot_FUNC(Py_mod_exec, demo_exec),
        PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
            PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
                PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
                    PySlot_SIZE(Py_mod_state_size, 53),
                    PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
                        PySlot_DATA(Py_mod_doc, "doc"),
                        PySlot_END
                    })),
                    PySlot_END,
                })),
                PySlot_END,
            })),
            PySlot_END,
        })),
    ENDCASE()
    CASE("nested_over_limit")
        PySlot_FUNC(Py_mod_exec, demo_exec),
        PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
            PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
                PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
                    PySlot_SIZE(Py_mod_state_size, 53),
                    PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
                        PySlot_DATA(Py_mod_doc, "doc"),
                        PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
                            PySlot_END
                        })),
                        PySlot_END
                    })),
                    PySlot_END,
                })),
                PySlot_END,
            })),
            PySlot_END,
        })),
    ENDCASE()
    CASE("nested_old")
        PySlot_FUNC(Py_mod_exec, demo_exec),
        PySlot_DATA(Py_mod_slots, ((PyModuleDef_Slot[]) {
            {Py_mod_doc, "doc"},
            {0},
        })),
    ENDCASE()
    CASE("nested_old_max")
        PySlot_FUNC(Py_mod_exec, demo_exec),
        PySlot_DATA(Py_mod_slots, ((PyModuleDef_Slot[]) {
            {Py_mod_slots, ((PyModuleDef_Slot[]) {
                {Py_mod_state_size, (void*)(intptr_t)53},
                {Py_mod_slots, ((PyModuleDef_Slot[]) {
                    {Py_mod_slots, ((PyModuleDef_Slot[]) {
                        {Py_mod_doc, "doc"},
                        {0},
                    })},
                    {0},
                })},
                {0},
            })},
            {0},
        })),
    ENDCASE()
    CASE("nested_old_over_limit")
        PySlot_FUNC(Py_mod_exec, demo_exec),
        PySlot_DATA(Py_mod_slots, ((PyModuleDef_Slot[]) {
            {Py_mod_slots, ((PyModuleDef_Slot[]) {
                {Py_mod_state_size, (void*)(intptr_t)53},
                {Py_mod_slots, ((PyModuleDef_Slot[]) {
                    {Py_mod_slots, ((PyModuleDef_Slot[]) {
                        {Py_mod_slots, ((PyModuleDef_Slot[]) {
                            {Py_mod_doc, "doc"},
                            {0},
                        })},
                        {0},
                    })},
                    {0},
                })},
                {0},
            })},
            {0},
        })),
    ENDCASE()
    CASE("nested_pingpong")
        PySlot_FUNC(Py_mod_exec, demo_exec),
        PySlot_DATA(Py_mod_slots, ((PyModuleDef_Slot[]) {
            {Py_slot_subslots, ((PySlot[]) {
                PySlot_DATA(Py_mod_slots, ((PyModuleDef_Slot[]) {
                    {Py_mod_state_size, (void*)(intptr_t)53},
                    {Py_slot_subslots, ((PySlot[]) {
                        PySlot_DATA(Py_mod_doc, "doc"),
                        PySlot_END
                    })},
                    {0},
                })),
                PySlot_END,
            })},
            {0},
        })),
    ENDCASE()
    CASE("repeat_create")
        PySlot_DATA(Py_mod_create, demo_create),
        PySlot_DATA(Py_mod_create, demo_create),
        PySlot_DATA(Py_mod_create, demo_create),
    ENDCASE()
    CASE("repeat_gil")
        PySlot_DATA(Py_mod_gil, Py_MOD_GIL_NOT_USED),
        PySlot_DATA(Py_mod_gil, Py_MOD_GIL_NOT_USED),
        PySlot_DATA(Py_mod_gil, Py_MOD_GIL_NOT_USED),
    ENDCASE()
    CASE("repeat_exec")
        PySlot_FUNC(Py_mod_exec, demo_exec),
        PySlot_FUNC(Py_mod_exec, demo_exec),
    ENDCASE()

#undef CASE
#undef ENDCASE
    if (!mod) {
        if (!PyErr_Occurred()) {
            PyErr_Format(PyExc_SystemError, "bad case: %s", case_name);
            return NULL;
        }
        return NULL;
    }
    if (PyModule_Check(mod)) {
        Py_ssize_t size;
        if (PyModule_GetStateSize(mod, &size) < 0) {
            Py_DECREF(mod);
            return NULL;
        }
        if (PyModule_AddIntConstant(mod, "state_size", (long)size) < 0) {
            Py_DECREF(mod);
            return NULL;
        }
        if (PyModule_Exec(mod) < 0) {
            return NULL;
        }
    }
    return mod;
}

static PyObject *
module_from_gil_slot(PyObject* Py_UNUSED(module), PyObject *args)
{
    long slot_number;
    PyObject *spec;
    if (!PyArg_ParseTuple(args, "lO", &slot_number, &spec)) {
        return NULL;
    }
    return PyModule_FromSlotsAndSpec((PySlot[]) {
        PySlot_DATA(Py_mod_abi, &abi_info),
        PySlot_PTR_STATIC((uint16_t)slot_number, Py_MOD_GIL_NOT_USED),
        PySlot_END
    }, spec);
}

static PyObject *
module_from_null_slot(PyObject* Py_UNUSED(module), PyObject *args)
{
    long slot_number;
    PyObject *spec;
    if (!PyArg_ParseTuple(args, "lO", &slot_number, &spec)) {
        return NULL;
    }
    uint16_t maybe_gil_slot = Py_mod_gil;
    if ((slot_number == 4) || (slot_number == 87)) {
        // Do not repeat the GIL slot
        maybe_gil_slot = Py_slot_invalid;
    }
    return PyModule_FromSlotsAndSpec((PySlot[]) {
        PySlot_DATA(Py_mod_abi, &abi_info),
        PySlot_DATA(Py_mod_name, "mymod"),
        PySlot_PTR_STATIC((uint16_t)slot_number, NULL),
        {
            .sl_id=maybe_gil_slot,
            .sl_flags=PySlot_OPTIONAL,
            .sl_ptr=Py_MOD_GIL_NOT_USED,
        },
        PySlot_END
    }, spec);
}

static PyMethodDef _TestMethods[] = {
    {"type_from_slots", type_from_slots, METH_VARARGS},
    {"module_from_gil_slot", module_from_gil_slot, METH_VARARGS},
    {"type_from_null_slot", type_from_null_slot, METH_VARARGS},
    {"type_from_null_spec_slot", type_from_null_spec_slot, METH_VARARGS},
    {"module_from_slots", module_from_slots, METH_VARARGS},
    {"module_from_null_slot", module_from_null_slot, METH_VARARGS},
    {NULL},
};
static PyMethodDef *TestMethods = _TestMethods;

int
_PyTestLimitedCAPI_Init_Slots(PyObject *m)
{
    if (PyModule_AddFunctions(m, TestMethods) < 0) {
        return -1;
    }

    return 0;
}