filesGeneration.py

import ctypes
import json
import re
import sys
from pathlib import WindowsPath, Path
from typing import Any, Dict, List, Union

# -----------------------------------------
RAYPYC_FOLDER_PATH = Path(__file__).parent / "raypyc"
DYNAMIC_LIBRARIES_PATH = RAYPYC_FOLDER_PATH / "libs"

wrapped_defines_names = []

wrapped_colors_names = []

wrapped_enums_names = []

wrapped_structures_names = []
wrapped_structures_names_stub = []

wrapped_aliases_names = []

wrapped_functions_names_stub = []

if sys.platform == "linux":
    _raylib_dynamic_library_name = "libraylib.so"
else:  # windows
    _raylib_dynamic_library_name = "raylib.dll"

if sys.platform == "linux":
    _raypyc_extra_functions_name = "raypyc_extra_functions.so"
else:  # windows
    _raypyc_extra_functions_name = "raypyc_extra_functions.dll"

_raylib_dynamic_library = ctypes.cdll.LoadLibrary(str(DYNAMIC_LIBRARIES_PATH / _raylib_dynamic_library_name))
_raypyc_extra_functions = ctypes.cdll.LoadLibrary(str(DYNAMIC_LIBRARIES_PATH / _raypyc_extra_functions_name))


# -----------------------------------------


# -----------------------------------------
def find_char_in_str(string: str, char: str) -> List[int]:
    """get the indexes of a char in a string"""
    return [i for i, ltr in enumerate(string) if ltr == char]


def underscore(_string: str) -> str:
    _string = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1_\2", _string)
    _string = re.sub(r"([a-z\d])([A-Z])", r"\1_\2", _string)
    _string = _string.replace("-", "_")
    return _string.lower()


def is_string_contained_in_list(_string: str, _list: List[str]) -> bool:
    for _item in _list:
        if _item in _string:
            return True
    return False


def generate_file(file_path: WindowsPath) -> None:
    if Path(file_path).exists():
        with open(Path(file_path), "w"):  # if the file exists we clean it
            pass
    else:
        print(f"the {file_path} doesn't exist, regenerating a new one")
        with open(file_path, "x"):
            pass


def add_text_to_file(file_path: WindowsPath, _string: str) -> None:
    with open(Path(file_path), "a") as file:
        file.write(_string)


def convert_c_type_to_python_type(c_type_string: str) -> str:
    """convert c type string to ctype type sting"""
    c_string_to_ctypes_string = {
        "bool": "c_bool",  # C type: _Bool  Python type: bool (1)
        "char": "c_char",  # C type: char  Python type: 1-character bytes object
        "wchar_t": "c_wchar",  # C type: wchar_t  Python type: 1-character string
        # 'char': c_byte,  # C type: char  Python type: int
        "unsignedchar": "c_ubyte",  # C type: unsigned char  Python type: int
        "short": "c_short",  # C type: short  Python  # type: int
        "unsignedshort": "c_ushort",  # C type: unsigned short  Python type: int
        "int": "c_int",  # C type: int  Python type: int
        "unsignedint": "c_uint",  # C type: unsigned int  Python type: int
        "long": "c_long",  # C type: long  Python type: int
        "unsignedlong": "c_ulong",  # C type: unsigned long  Python type: int
        "uint64": "c_longlong",  # C type: __int64 or long-long  Python type: int
        "unsigneduint64": "c_ulonglong",  # C type: unsigned __int64 or unsigned long-long  Python type: int
        "unsignedlonglong": "c_ulonglong",  # C type: unsigned __int64 or unsigned long-long  Python type: int
        "size_t": "c_size_t",  # C type: unsigned size_t  Python type: int
        "ssize_t": "c_ssize_t",  # C type: ssize_t or Py_ssize_t  Python type: int
        "float": "c_float",  # C type: float  Python type: float
        "double": "c_double",  # C type: double  Python type: float
        "longdouble": "c_longdouble",  # C type: long double  Python type: float
        "char*": "c_char_p",  # C type: char* (NUL terminated)  Python type: bytes object or None
        "wchar_t*": "c_wchar_p",  # C type: wchar_t* (NUL terminated)  Python type: string object or None
        "void*": "c_void_p",  # C type: wchar_t* (NUL terminated)  Python type: int or None
        "void": "None",  # C type: void  Python type: None
    }

    c_type_string = c_type_string.replace(" ", "").replace(
        "const", ""
    )  # remove spaces, and "const" because there isn't really a const type in python...
    is_array = "]" in c_type_string
    pointer_level = c_type_string.count("*")

    if c_type_string == "void":  # void shouldn't be in the form of ctypes.None
        return "None"

    if c_type_string in c_string_to_ctypes_string:  # "regular" value not a pointer or an array
        return "ctypes." + c_string_to_ctypes_string[c_type_string]

    if is_array and pointer_level > 0:  # array of pointers to structures
        type_of_array = c_type_string.split("[")[0]
        array_size = c_type_string.split("[")[1][:-1]
        type_of_array_without_pointers = type_of_array.replace("*", "")
        if type_of_array in c_string_to_ctypes_string:  # basic type pointer (int*, char*, float*, ...)
            return f"ctypes.{c_string_to_ctypes_string[type_of_array]} * {array_size}"
        if (
            type_of_array_without_pointers in c_string_to_ctypes_string
        ):  # basic type pointer(probably double+ pointer level) (int**, char**, float**, ...)
            type_of_array_end = c_string_to_ctypes_string[type_of_array_without_pointers]
            for i in range(pointer_level):
                type_of_array_end = f"ctypes.POINTER({type_of_array_end})"
            return f"ctypes.{type_of_array_end} * {array_size}"
        else:  # a struct array pointer level 1+ or just a pointer level 1
            type_of_array_end = type_of_array_without_pointers
            for i in range(pointer_level):
                type_of_array_end = f"ctypes.POINTER({type_of_array_end})"
            return f"{type_of_array_end} * {array_size}"
    elif is_array:
        type_of_array = c_type_string.split("[")[0]
        array_size = c_type_string.split("[")[1][:-1]
        if type_of_array in c_string_to_ctypes_string:  # basic type array (int, char, float, ...)
            return f"ctypes.{c_string_to_ctypes_string[type_of_array]} * {array_size}"
        else:  # a struct array
            return f"{type_of_array} * {array_size}"
    elif pointer_level > 0:
        type_without_pointers = c_type_string.replace("*", "")
        if c_type_string in c_string_to_ctypes_string:  # basic type pointer (int*, char*, float*, ...)
            return f"ctypes.{c_string_to_ctypes_string[c_type_string]}"
        if (
            type_without_pointers in c_string_to_ctypes_string
        ):  # basic type pointer(probably double+ pointer level) (int**, char**, float**, ...)
            type_of_pointer_end = "ctypes." + c_string_to_ctypes_string[type_without_pointers]
            for i in range(pointer_level):
                type_of_pointer_end = f"ctypes.POINTER({type_of_pointer_end})"
            return f"{type_of_pointer_end}"
        else:  # a struct pointer level 1+ or just a pointer level 1
            type_of_pointer_end = c_type_string.replace("*", "")
            for i in range(pointer_level):
                type_of_pointer_end = f"ctypes.POINTER({type_of_pointer_end})"
            return f"{type_of_pointer_end}"

    return c_type_string  # a struct


# -----------------------------------------
def generate_color_code(define_data: Dict[str, Union[str, float, int]], for_stub: bool = False) -> str:
    if define_data["type"] == "COLOR":
        ints_array_string = define_data["value"].split("{")[1].split("}")[0].replace(" ", "").split(",")
        temp = f"{define_data['name']}: raypyc.structures.Color"
        if not for_stub:
            temp += f" = raypyc.structures.Color({ints_array_string[0]}, {ints_array_string[1]}, {ints_array_string[2]}, {ints_array_string[3]})"
        temp += f"{('  # ' + define_data['description']) if define_data['description'] != '' else ''}"
        return temp
    else:
        return ""


def generate_define_code(define_data: Dict[str, Union[str, float, int]], for_stub: bool = False) -> str:
    if not define_data["type"] in ["FLOAT_MATH", "FLOAT", "DOUBLE", "STRING", "INT"]:
        return ""

    elif define_data["type"] == "FLOAT_MATH":
        temp = f"{define_data['name']}: float"
        if not for_stub:
            temp += f" = {define_data['value'].replace('f', '')}"
        temp += f"{('  # ' + define_data['description']) if define_data['description'] != '' else ''}"
        return temp

    elif define_data["type"] == "INT":
        temp = f"{define_data['name']}: int"
        if not for_stub:
            temp += f" = {define_data['value']}"
        temp += f"{('  # ' + define_data['description']) if define_data['description'] != '' else ''}"
        return temp

    elif define_data["type"] in ["DOUBLE", "FLOAT"]:
        temp = f"{define_data['name']}: float"
        if not for_stub:
            temp += f" = {define_data['value']}"
        temp += f"{('  # ' + define_data['description']) if define_data['description'] != '' else ''}"
        return temp

    elif define_data["type"] == "STRING":
        temp = f"{define_data['name']}: str"
        if not for_stub:
            temp += f" = \"{define_data['value']}\""
        temp += f"{('  # ' + define_data['description']) if define_data['description'] != '' else ''}"
        return temp
    else:
        return ""


def generate_dummy_struct_code(struct_name: str, bytes_size: int, for_stub: bool = False) -> str:
    _string = f'class {struct_name}(ctypes.Structure):\n\t"""dummy structure"""\n'
    if not for_stub:
        _string += f'\t_fields_ = [\n\t\t("buffer", ctypes.c_byte * {bytes_size})\n\t]\n\n'
    else:
        _string += f"\t@property\n\tdef buffer(self) -> ctypes.c_byte * {bytes_size}:\n"
        _string += f"\t\t...\n\n"
        _string += f"\t@buffer.setter\n\tdef buffer(self, i: ctypes.c_byte * {bytes_size}) -> None:\n"
        _string += f"\t\t...\n\n"

    return _string


def generate_struct_code(struct_data: Dict[str, Union[str, List[Dict[str, str]]]], for_stub: bool = False) -> str:
    _string = ""
    struct_fields = ""
    struct_setters_getters_string = ""
    _string += f"class {struct_data['name']}(ctypes.Structure):\n\t\"\"\"{struct_data['description']}\"\"\"\n"

    if not for_stub:
        struct_fields = "\t_fields_ = [\n"
        for struct_data_field in struct_data["fields"]:
            struct_fields += f"\t\t('{struct_data_field['name']}', {convert_c_type_to_python_type(struct_data_field['type'])}),"
            if struct_data_field["description"] != "":
                struct_fields += f"  # {struct_data_field['description']}"
            struct_fields += "\n"
        temp = find_char_in_str(struct_fields, ",")
        if len(temp) != 0:
            struct_fields = struct_fields[: temp[-1]] + struct_fields[temp[-1] + 1 :]
        struct_fields += "\t]\n\n"
    _string += struct_fields

    if for_stub:
        for struct_data_field in struct_data["fields"]:
            use_type = convert_c_type_to_python_type(struct_data_field["type"])
            struct_setters_getters_string += f"\t@property\n\tdef {struct_data_field['name']}(self) -> {use_type}:\n"
            struct_setters_getters_string += f"\t\t...\n\n"
            struct_setters_getters_string += (
                f"\t@{struct_data_field['name']}.setter\n\tdef {struct_data_field['name']}(self, i: {use_type}) -> None:\n"
            )
            struct_setters_getters_string += f"\t\t...\n\n"
    _string += struct_setters_getters_string

    return _string


def generate_alias_code(alias_name: str, object_name: str) -> str:
    return f"{alias_name} = {object_name}\n"


def generate_enum_code(enum_data, for_stub=False):
    _string = ""
    _string += f"class {enum_data['name']}(enum.IntEnum):\n"
    if enum_data["description"] != "":
        _string += f"\t\"\"\"{enum_data['description']}\"\"\"\n"

    for value in enum_data["values"]:
        _string += f"\t{value['name']}: int"
        if not for_stub:
            _string += f" = {value['value']}"
        if value["description"] != "":
            _string += f"  # {value['description']}"
        _string += "\n"

    _string += "\n"

    return _string


def generate_function_signature_code(function_data: Dict[str, Union[str, List[Dict[str, str]]]]) -> str:
    function_string = f"def {function_data['name']}("
    if "params" in function_data.keys():  # only return stuff
        for param in function_data["params"]:
            function_string += f"{param['name']}: {convert_c_type_to_python_type(param['type'])}, "

        function_string = function_string[:-2]

    function_string += ") -> "
    function_string += (
        f"{convert_c_type_to_python_type(function_data['returnType'])}:\n\t\"\"\"{function_data['description']}\"\"\"\n\t...\n\n"
    )

    return function_string


# -----------------------------------------
def generate_colors_code(defines_api: List[Dict[str, Union[str, float, int]]], for_stub: bool = False) -> str:
    _string = ""
    for define in defines_api:
        if for_stub or define["name"] not in wrapped_defines_names:
            color_string_logic = generate_color_code(define, for_stub)
            if color_string_logic != "":
                wrapped_defines_names.append(define["name"])
                color_string_logic += "\n"

            _string += color_string_logic
    return _string


def generate_defines_code(defines_api: List[Dict[str, Union[str, float, int]]], for_stub: bool = False) -> str:
    _string = ""
    for define in defines_api:
        if for_stub or define["name"] not in wrapped_defines_names:
            define_string_logic = generate_define_code(define, for_stub)
            if define_string_logic != "":
                wrapped_defines_names.append(define["name"])
                define_string_logic += "\n"

            _string += define_string_logic
    return _string


def generate_dummy_structs_code(names: List[str], for_stub: bool = False) -> str:
    _string = ""
    for name in names:
        function_of_size = _raypyc_extra_functions.__getattr__(f"Get{name}Size")
        function_of_size.argtypes = None
        function_of_size.restype = ctypes.c_int

        dummy_struct_code = generate_dummy_struct_code(name, int(function_of_size()), for_stub)
        if dummy_struct_code != "":
            dummy_struct_code += "\n"

        _string += dummy_struct_code
    return _string


def generate_structs_aliases_code(
    structs_api: List[Union[Dict[str, Union[str, List[Dict[str, str]]]], Any]],
    aliases_api: List[Union[Dict[str, str], Any]],
    for_stub: bool = False,
) -> str:
    _string = ""
    if not for_stub:
        _wrapped_structures_names = wrapped_structures_names
    else:
        _wrapped_structures_names = wrapped_structures_names_stub
    for struct in structs_api:
        if struct["name"] not in _wrapped_structures_names:
            struct_string_logic = generate_struct_code(struct, for_stub)
            if struct_string_logic != "":
                _wrapped_structures_names.append(struct["name"])
                struct_string_logic += "\n"

            _string += struct_string_logic

            for alias in aliases_api:
                if struct["name"] == alias["type"]:
                    if alias["name"] not in _wrapped_structures_names:
                        alias_string_logic = ""
                        alias_string_logic += generate_alias_code(alias["name"], struct["name"])
                        if alias_string_logic != "":
                            _wrapped_structures_names.append(alias["name"])
                        alias_string_logic += "\n\n"

                        _string += alias_string_logic

    return _string


def generate_structures_dictionary_code(wrapped_structures: List[str], for_stub: bool = False) -> str:
    if not for_stub:
        dictionary_sting = "__structs = {\n"
        for struct in wrapped_structures:
            dictionary_sting += f'\t"{struct}": {struct},\n'
        dictionary_sting = dictionary_sting[:-2]
        dictionary_sting += "\n}\n"
        return dictionary_sting
    else:
        dictionary_sting = "__structs: dict[str, Type["
        for struct in wrapped_structures:
            dictionary_sting += f"{struct} | "
        dictionary_sting = dictionary_sting[:-3]
        dictionary_sting += "]] = {\n\t...\n}\n"
        return dictionary_sting


def generate_enums_code(enums_api, for_stub=False):
    _string = ""
    for enum in enums_api:
        if for_stub or enum["name"] not in wrapped_enums_names:
            enum_string_logic = generate_enum_code(enum, for_stub)
            if enum_string_logic != "":
                wrapped_enums_names.append(enum["name"])
                enum_string_logic += "\n"

            _string += enum_string_logic
    return _string


def check_for_functions_that_can_wrap(
    functions_api: List[Union[Any, Dict[str, Union[str, List[Dict[str, str]]]], Dict[str, str]]]
) -> List[Union[Any, Dict[str, Union[str, List[Dict[str, str]]]], Dict[str, str]]]:
    functions_that_can_be_wrap = []
    functions_that_cant_be_wrap = []

    for function in functions_api:
        do_wrapper_this_function = True
        if "params" in function.keys():
            for function_param in function["params"]:
                if is_string_contained_in_list(
                    function_param["type"],
                    [
                        "Sound",
                        "AudioCallback",
                        "SaveFileTextCallback",
                        "LoadFileTextCallback",
                        "TraceLogCallback",
                        "LoadFileDataCallback",
                        "SaveFileDataCallback",
                    ],
                ):
                    do_wrapper_this_function = False
                    break

        if do_wrapper_this_function:
            if is_string_contained_in_list(
                function["returnType"],
                [
                    "Sound",
                    "AudioCallback",
                    "SaveFileTextCallback",
                    "LoadFileTextCallback",
                    "TraceLogCallback",
                    "LoadFileDataCallback",
                    "SaveFileDataCallback",
                ],
            ):
                do_wrapper_this_function = False

        if do_wrapper_this_function:
            functions_that_can_be_wrap.append(function)
        else:
            functions_that_cant_be_wrap.append(function)

    return functions_that_can_be_wrap


def generate_functions_code(functions_set: List[Union[Any, Dict[str, Union[str, List[Dict[str, str]]]], Dict[str, str]]]) -> str:
    _string = ""
    for function in functions_set:
        if function["name"] not in wrapped_functions_names_stub:
            wrapped_functions_names_stub.append(function["name"])
            function_copy = function.copy()
            name_of_function = (
                underscore(function["name"])
                .replace("3_d", "_3d")
                .replace("2_d", "_2d")
                .replace("vector_2", "vector_2")
                .replace("vector_3", "vector3_")
            )
            function_copy["name"] = name_of_function
            _string += generate_function_signature_code(function_copy)
    return _string


# -----------------------------------------

# load config data
with open(Path(RAYPYC_FOLDER_PATH / "config_api.json")) as reader:
    config_api = json.load(reader)

config_api_defines = config_api["defines"]
config_api_structs = config_api["structs"]
config_api_aliases = config_api["aliases"]
config_api_enums = config_api["enums"]
config_api_functions = config_api["functions"]

# load rlgl data
with open(Path(RAYPYC_FOLDER_PATH / "rlgl_api.json")) as reader:
    rlgl_api = json.load(reader)

rlgl_api_defines = rlgl_api["defines"]
rlgl_api_structs = rlgl_api["structs"]
rlgl_api_aliases = rlgl_api["aliases"]
rlgl_api_enums = rlgl_api["enums"]
rlgl_api_functions = rlgl_api["functions"]

# load raylib data
with open(Path(RAYPYC_FOLDER_PATH / "raylib_api.json")) as reader:
    raylib_api = json.load(reader)

raylib_api_defines = raylib_api["defines"]
raylib_api_structs = raylib_api["structs"]
raylib_api_aliases = raylib_api["aliases"]
raylib_api_enums = raylib_api["enums"]
raylib_api_functions = raylib_api["functions"]

# load raymath data
with open(Path(RAYPYC_FOLDER_PATH / "raymath_api.json")) as reader:
    raymath_api = json.load(reader)

raymath_api_defines = raymath_api["defines"]
raymath_api_structs = raymath_api["structs"]
raymath_api_aliases = raymath_api["aliases"]
raymath_api_enums = raymath_api["enums"]
raymath_api_functions = raymath_api["functions"]

# load raygui data
with open(Path(RAYPYC_FOLDER_PATH / "raygui_api.json")) as reader:
    raygui_api = json.load(reader)

raygui_api_defines = raygui_api["defines"]
raygui_api_structs = raygui_api["structs"]
raygui_api_aliases = raygui_api["aliases"]
raygui_api_enums = raygui_api["enums"]
raygui_api_functions = raygui_api["functions"]

# -----------------------------------------
# note that we have to generate the none stub-code first, because we need all the wrapped_*_names lists to be updated first
# -----------------------------------------

# generate colors files and add import stuff
generate_file(RAYPYC_FOLDER_PATH / "colors/__init__.py")
add_text_to_file(RAYPYC_FOLDER_PATH / "colors/__init__.py", "import raypyc\n\n\n")
generate_file(RAYPYC_FOLDER_PATH / "colors/__init__.pyi")
add_text_to_file(RAYPYC_FOLDER_PATH / "colors/__init__.pyi", "import raypyc\n\n\n")

# generate colors code and add colors code to files
add_text_to_file(RAYPYC_FOLDER_PATH / "colors/__init__.py", generate_colors_code(config_api_defines, for_stub=False))
add_text_to_file(RAYPYC_FOLDER_PATH / "colors/__init__.py", generate_colors_code(rlgl_api_defines, for_stub=False))
add_text_to_file(RAYPYC_FOLDER_PATH / "colors/__init__.py", generate_colors_code(raylib_api_defines, for_stub=False))
add_text_to_file(RAYPYC_FOLDER_PATH / "colors/__init__.py", generate_colors_code(raymath_api_defines, for_stub=False))
add_text_to_file(RAYPYC_FOLDER_PATH / "colors/__init__.py", generate_colors_code(raygui_api_defines, for_stub=False))
add_text_to_file(RAYPYC_FOLDER_PATH / "colors/__init__.pyi", generate_colors_code(config_api_defines, for_stub=True))
add_text_to_file(RAYPYC_FOLDER_PATH / "colors/__init__.pyi", generate_colors_code(rlgl_api_defines, for_stub=True))
add_text_to_file(RAYPYC_FOLDER_PATH / "colors/__init__.pyi", generate_colors_code(raylib_api_defines, for_stub=True))
add_text_to_file(RAYPYC_FOLDER_PATH / "colors/__init__.pyi", generate_colors_code(raymath_api_defines, for_stub=True))
add_text_to_file(RAYPYC_FOLDER_PATH / "colors/__init__.pyi", generate_colors_code(raygui_api_defines, for_stub=True))
# -----------------------------------------

# generate defines files
generate_file(RAYPYC_FOLDER_PATH / "defines/__init__.py")
generate_file(RAYPYC_FOLDER_PATH / "defines/__init__.pyi")

# generate defines code ans add defines code to files
add_text_to_file(RAYPYC_FOLDER_PATH / "defines/__init__.py", generate_defines_code(config_api_defines, for_stub=False))
add_text_to_file(RAYPYC_FOLDER_PATH / "defines/__init__.py", generate_defines_code(rlgl_api_defines, for_stub=False))
add_text_to_file(RAYPYC_FOLDER_PATH / "defines/__init__.py", generate_defines_code(raylib_api_defines, for_stub=False))
add_text_to_file(RAYPYC_FOLDER_PATH / "defines/__init__.py", generate_defines_code(raymath_api_defines, for_stub=False))
add_text_to_file(RAYPYC_FOLDER_PATH / "defines/__init__.py", generate_defines_code(raygui_api_defines, for_stub=False))
add_text_to_file(RAYPYC_FOLDER_PATH / "defines/__init__.pyi", generate_defines_code(config_api_defines, for_stub=True))
add_text_to_file(RAYPYC_FOLDER_PATH / "defines/__init__.pyi", generate_defines_code(rlgl_api_defines, for_stub=True))
add_text_to_file(RAYPYC_FOLDER_PATH / "defines/__init__.pyi", generate_defines_code(raylib_api_defines, for_stub=True))
add_text_to_file(RAYPYC_FOLDER_PATH / "defines/__init__.pyi", generate_defines_code(raymath_api_defines, for_stub=True))
add_text_to_file(RAYPYC_FOLDER_PATH / "defines/__init__.pyi", generate_defines_code(raygui_api_defines, for_stub=True))
# -----------------------------------------

# generate structures files and add import stuff
generate_file(RAYPYC_FOLDER_PATH / "structures/__init__.py")
add_text_to_file(RAYPYC_FOLDER_PATH / "structures/__init__.py", "import ctypes\nfrom raypyc.defines import *\n\n\n")
generate_file(RAYPYC_FOLDER_PATH / "structures/__init__.pyi")
add_text_to_file(
    RAYPYC_FOLDER_PATH / "structures/__init__.pyi", "import ctypes\nfrom raypyc.defines import *\nfrom typing import Type\n\n\n"
)

# generate dummy structures code and add dummy structures code to files
add_text_to_file(
    RAYPYC_FOLDER_PATH / "structures/__init__.py", generate_dummy_structs_code(["rAudioBuffer", "rAudioProcessor"], for_stub=False)
)
add_text_to_file(
    RAYPYC_FOLDER_PATH / "structures/__init__.pyi", generate_dummy_structs_code(["rAudioBuffer", "rAudioProcessor"], for_stub=True)
)

# generate structures code add structures code to files
add_text_to_file(
    RAYPYC_FOLDER_PATH / "structures/__init__.py",
    generate_structs_aliases_code(config_api_structs, config_api_aliases, for_stub=False),
)
add_text_to_file(
    RAYPYC_FOLDER_PATH / "structures/__init__.py", generate_structs_aliases_code(rlgl_api_structs, rlgl_api_aliases, for_stub=False)
)
add_text_to_file(
    RAYPYC_FOLDER_PATH / "structures/__init__.py",
    generate_structs_aliases_code(raylib_api_structs, raylib_api_aliases, for_stub=False),
)
add_text_to_file(
    RAYPYC_FOLDER_PATH / "structures/__init__.py",
    generate_structs_aliases_code(raymath_api_structs, raymath_api_aliases, for_stub=False),
)
add_text_to_file(
    RAYPYC_FOLDER_PATH / "structures/__init__.py",
    generate_structs_aliases_code(raygui_api_structs, raygui_api_aliases, for_stub=False),
)
add_text_to_file(
    RAYPYC_FOLDER_PATH / "structures/__init__.pyi",
    generate_structs_aliases_code(config_api_structs, config_api_aliases, for_stub=True),
)
add_text_to_file(
    RAYPYC_FOLDER_PATH / "structures/__init__.pyi", generate_structs_aliases_code(rlgl_api_structs, rlgl_api_aliases, for_stub=True)
)
add_text_to_file(
    RAYPYC_FOLDER_PATH / "structures/__init__.pyi",
    generate_structs_aliases_code(raylib_api_structs, raylib_api_aliases, for_stub=True),
)
add_text_to_file(
    RAYPYC_FOLDER_PATH / "structures/__init__.pyi",
    generate_structs_aliases_code(raymath_api_structs, raymath_api_aliases, for_stub=True),
)
add_text_to_file(
    RAYPYC_FOLDER_PATH / "structures/__init__.pyi",
    generate_structs_aliases_code(raygui_api_structs, raygui_api_aliases, for_stub=True),
)

# generate structures-dictionary code and add structures-dictionary to files
add_text_to_file(
    RAYPYC_FOLDER_PATH / "structures/__init__.py", generate_structures_dictionary_code(wrapped_structures_names, for_stub=False)
)
add_text_to_file(
    RAYPYC_FOLDER_PATH / "structures/__init__.pyi",
    generate_structures_dictionary_code(wrapped_structures_names_stub, for_stub=True),
)
# -----------------------------------------

# generate enums files and add import stuff
generate_file(RAYPYC_FOLDER_PATH / "enums/__init__.py")
add_text_to_file(RAYPYC_FOLDER_PATH / "enums/__init__.py", "import enum\n\n\n")
generate_file(RAYPYC_FOLDER_PATH / "enums/__init__.pyi")
add_text_to_file(RAYPYC_FOLDER_PATH / "enums/__init__.pyi", "import enum\n\n\n")

# generate enums code and add enums code to files
add_text_to_file(RAYPYC_FOLDER_PATH / "enums/__init__.py", generate_enums_code(config_api_enums, for_stub=False))
add_text_to_file(RAYPYC_FOLDER_PATH / "enums/__init__.py", generate_enums_code(rlgl_api_enums, for_stub=False))
add_text_to_file(RAYPYC_FOLDER_PATH / "enums/__init__.py", generate_enums_code(raylib_api_enums, for_stub=False))
add_text_to_file(RAYPYC_FOLDER_PATH / "enums/__init__.py", generate_enums_code(raymath_api_enums, for_stub=False))
add_text_to_file(RAYPYC_FOLDER_PATH / "enums/__init__.py", generate_enums_code(raygui_api_enums, for_stub=False))
add_text_to_file(RAYPYC_FOLDER_PATH / "enums/__init__.pyi", generate_enums_code(config_api_enums, for_stub=True))
add_text_to_file(RAYPYC_FOLDER_PATH / "enums/__init__.pyi", generate_enums_code(rlgl_api_enums, for_stub=True))
add_text_to_file(RAYPYC_FOLDER_PATH / "enums/__init__.pyi", generate_enums_code(raylib_api_enums, for_stub=True))
add_text_to_file(RAYPYC_FOLDER_PATH / "enums/__init__.pyi", generate_enums_code(raymath_api_enums, for_stub=True))
add_text_to_file(RAYPYC_FOLDER_PATH / "enums/__init__.pyi", generate_enums_code(raygui_api_enums, for_stub=True))

# -----------------------------------------

generate_file(RAYPYC_FOLDER_PATH / "__init__.pyi")
add_text_to_file(
    RAYPYC_FOLDER_PATH / "__init__.pyi",
    "import ctypes\nfrom raypyc.defines import *\nfrom raypyc.defines import *\nfrom raypyc.colors import *\nfrom raypyc.enums import *\nfrom raypyc.structures import *\n\n\n",
)

# check what function can be wrapped
config_functions_to_wrapped = check_for_functions_that_can_wrap(config_api_functions)
rlgl_functions_to_wrapped = check_for_functions_that_can_wrap(rlgl_api_functions)
raylib_functions_to_wrapped = check_for_functions_that_can_wrap(raylib_api_functions)
raymath_functions_to_wrapped = check_for_functions_that_can_wrap(raymath_api_functions)
raygui_functions_to_wrapped = check_for_functions_that_can_wrap(raygui_api_functions)

# add the functions signature strings files
add_text_to_file(RAYPYC_FOLDER_PATH / "__init__.pyi", generate_functions_code(config_functions_to_wrapped))
add_text_to_file(RAYPYC_FOLDER_PATH / "__init__.pyi", generate_functions_code(rlgl_functions_to_wrapped))
add_text_to_file(RAYPYC_FOLDER_PATH / "__init__.pyi", generate_functions_code(raylib_functions_to_wrapped))
add_text_to_file(RAYPYC_FOLDER_PATH / "__init__.pyi", generate_functions_code(raymath_functions_to_wrapped))
add_text_to_file(RAYPYC_FOLDER_PATH / "__init__.pyi", generate_functions_code(raygui_functions_to_wrapped))