macro_rules! device_procs {
    ($bname:literal $name:ident $pfn:ident) => {
        $($bname => std::mem::transmute::<_, vk::PFN_vkVoidFunction>($name as vk::$pfn),)*
    }
}

macro_rules! get_device_proc_match {
    ($match_name:ident $device:ident $pname:ident ) => {
        match $match_name.to_bytes() {
            device_procs!(b"vkGetDeviceProcAddr"       CheakoCache_GetDeviceProcAddr PFN_vkGetDeviceProcAddr)
            device_procs!(b"vkAllocateMemory"          allocate_memory               PFN_vkAllocateMemory)
            device_procs!(b"vkFreeMemory"              free_memory                   PFN_vkFreeMemory)
            device_procs!(b"vkCreateSemaphore"         create_semaphore              PFN_vkCreateSemaphore)
            device_procs!(b"vkDestroySemaphore"        destroy_semaphore             PFN_vkDestroySemaphore)
            device_procs!(b"vkCreateFence"             create_fence                  PFN_vkCreateFence)
            device_procs!(b"vkDestroyFence"            destroy_fence                 PFN_vkDestroyFence)
            device_procs!(b"vkCreateBuffer"            create_buffer                 PFN_vkCreateBuffer)
            device_procs!(b"vkDestroyBuffer"           destroy_buffer                PFN_vkDestroyBuffer)
            device_procs!(b"vkCreateRenderPass"        create_render_pass            PFN_vkCreateRenderPass)
            device_procs!(b"vkDestroyRenderPass"       destroy_render_pass           PFN_vkDestroyRenderPass)
            device_procs!(b"vkCreateGraphicsPipelines" create_graphics_pipeline      PFN_vkCreateGraphicsPipelines)
            device_procs!(b"vkDestroyPipeline"         destroy_pipeline              PFN_vkDestroyPipeline)
            device_procs!(b"vkCreateImage"             create_image                  PFN_vkCreateImage)
            device_procs!(b"vkDestroyImage"            destroy_image                 PFN_vkDestroyImage)
            device_procs!(b"vkCreateImageView"         create_image_view             PFN_vkCreateImageView)
            device_procs!(b"vkDestroyImageView"        destroy_image_view            PFN_vkDestroyImageView)
            device_procs!(b"vkQueuePresentKHR"         queue_present                 PFN_vkQueuePresentKHR)
            device_procs!(b"vkGetDeviceQueue"          get_device_queue              PFN_vkGetDeviceQueue)
            _ => (DEVICE
                .read()
                .unwrap()
                .get(&$device)
                .unwrap()
                .instance_fn
                .get_device_proc_addr)($device, $pname),
        }
    }
}

#[no_mangle]
pub unsafe extern "system" fn CheakoCache_GetDeviceProcAddr(
    device: vk::Device,
    p_name: *const std::os::raw::c_char,
) -> vk::PFN_vkVoidFunction {
    let result = catch_unwind(|| {
        use handlers::{
            buffer::*,
            fence::*,
            images::{image::*, view::*},
            memory::*,
            present::*,
            renders::{graphics_pipeline::*, render_pass::*},
            semaphore::*,
        };
        let name = ffi::CStr::from_ptr(p_name);
        get_device_proc_match! (
            name device p_name
        )
    });
    assert!(result.is_ok());
    result.unwrap()
}

macro_rules! get_instance_proc_match {
    {$match_name:ident $instance:ident $pname:ident $($bname:literal $name:ident $pfn:ident)*} => {
        match $match_name.to_bytes() {
            $($bname => std::mem::transmute::<_, vk::PFN_vkVoidFunction>(
                $name as vk::$pfn,
            )),*,
            _ => {
                assert!(ENTRY_INIT.is_completed());
                (ENTRY.assume_init_ref().get_instance_proc_addr)($instance, $pname)
            }
        }
    }
}

#[no_mangle]
pub unsafe extern "system" fn CheakoCache_GetInstanceProcAddr(
    instance: vk::Instance,
    p_name: *const std::os::raw::c_char,
) -> vk::PFN_vkVoidFunction {
    let result = catch_unwind(|| {
        use handlers::{
            buffer::*,
            fence::*,
            images::{image::*, view::*},
            memory::*,
            present::*,
            renders::{graphics_pipeline::*, render_pass::*},
            semaphore::*,
        };
        let name = ffi::CStr::from_ptr(p_name);
        get_instance_proc_match! {
            name instance p_name
            b"vkCreateInstance"           create_instance                 PFN_vkCreateInstance
            b"vkEnumeratePhysicalDevices" enumerate_physical_devices      PFN_vkEnumeratePhysicalDevices
            b"vkCreateDevice"             create_device                   PFN_vkCreateDevice
            b"vkGetInstanceProcAddr"      CheakoCache_GetInstanceProcAddr PFN_vkGetInstanceProcAddr
            b"vkGetDeviceProcAddr"        CheakoCache_GetDeviceProcAddr   PFN_vkGetDeviceProcAddr
            b"vkAllocateMemory"           allocate_memory                 PFN_vkAllocateMemory
            b"vkFreeMemory"               free_memory                     PFN_vkFreeMemory
            b"vkCreateSemaphore"          create_semaphore                PFN_vkCreateSemaphore
            b"vkDestroySemaphore"         destroy_semaphore               PFN_vkDestroySemaphore
            b"vkCreateBuffer"             create_buffer                   PFN_vkCreateBuffer
            b"vkDestroyBuffer"            destroy_buffer                  PFN_vkDestroyBuffer
            b"vkCreateFence"              create_fence                    PFN_vkCreateFence
            b"vkDestroyFence"             destroy_fence                   PFN_vkDestroyFence
            b"vkCreateRenderPass"         create_render_pass              PFN_vkCreateRenderPass
            b"vkDestroyRenderPass"        destroy_render_pass             PFN_vkDestroyRenderPass
            b"vkCreateGraphicsPipelines"  create_graphics_pipeline        PFN_vkCreateGraphicsPipelines
            b"vkDestroyPipeline"          destroy_pipeline                PFN_vkDestroyPipeline
            b"vkCreateImage"              create_image                    PFN_vkCreateImage
            b"vkDestroyImage"             destroy_image                   PFN_vkDestroyImage
            b"vkCreateImageView"          create_image_view               PFN_vkCreateImageView
            b"vkDestroyImageView"         destroy_image_view              PFN_vkDestroyImageView
            b"vkQueuePresentKHR"          queue_present                   PFN_vkQueuePresentKHR
            b"vkGetDeviceQueue"           get_device_queue                PFN_vkGetDeviceQueue
        }
    });
    assert!(result.is_ok());
    result.unwrap()
}