// Copyright 2022 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

use ash::extensions::{
    ext::DebugUtils,
//     // khr::{Surface, Swapchain},
};
use ash::{self, vk};
use std::borrow::Cow;
// use std::cell::RefCell;
// use std::default::Default;
use std::ffi::CStr;
// use std::ops::Drop;
use std::os::raw::c_char;

use anyhow::Error;
// use std::default::Default;
// use std::ffi::CStr;
// use std::io::Cursor;
// use std::mem;
// use std::mem::align_of;

// macro_rules! cstr {
//     ( $bytes:expr ) => {
//         CStr::from_bytes_with_nul($bytes).expect("CStr must end with '\\0'")
//     };
// }

// macro_rules! vulkan_version {
//     ( $major:expr, $minor:expr, $patch:expr ) => {
//         ($major as u32) << 22 | ($minor as u32) << 12 | ($patch as u32)
//     };
// }

// unsafe fn create_from<T>(f: impl FnOnce(*mut T)) -> T {
//     let mut value = MaybeUninit::uninit();
//     f(value.as_mut_ptr());
//     value.assume_init()
// }

// fn create_vk_instance() -> Result<vk::Instance, Error> {
//     let entry_points = fvk::entry_points();
//     let mut instance: vk::Instance = 0;
//     let create_instance_result = unsafe {
//         entry_points.CreateInstance(
//             &vk::InstanceCreateInfo {
//                 sType: vk::STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
//                 pNext: ptr::null(),
//                 flags: 0,
//                 pApplicationInfo: &vk::ApplicationInfo {
//                     sType: vk::STRUCTURE_TYPE_APPLICATION_INFO,
//                     pNext: ptr::null(),
//                     pApplicationName: cstr!(b"flatland-view-provider\0").as_ptr(),
//                     applicationVersion: 0,
//                     pEngineName: ptr::null(),
//                     engineVersion: 0,
//                     apiVersion: vulkan_version!(1, 1, 0),
//                 },
//                 enabledLayerCount: 0,
//                 ppEnabledLayerNames: ptr::null(),
//                 enabledExtensionCount: 0,
//                 ppEnabledExtensionNames: ptr::null(),
//             },
//             ptr::null(),
//             &mut instance as *mut vk::Instance,
//         )
//     };
//     if create_instance_result != vk::SUCCESS {
//         return Err(anyhow!("Failed to create vk::Instance"));
//     }
//     Ok(instance)
// }

// fn get_vk_physical_device(instance: vk::Instance) -> Option<vk::PhysicalDevice> {
//     let instance_pointers = fvk::instance_pointers(instance);
//     let physical_devices = {
//         let mut len = unsafe {
//             create_from(|ptr| {
//                 instance_pointers.EnumeratePhysicalDevices(instance, ptr, ptr::null_mut());
//             })
//         };
//         let mut physical_devices: Vec<vk::PhysicalDevice> = Vec::with_capacity(len as usize);
//         unsafe {
//             let enumerate_result = instance_pointers.EnumeratePhysicalDevices(
//                 instance,
//                 &mut len,
//                 physical_devices.as_mut_ptr(),
//             );
//             assert!(enumerate_result == vk::SUCCESS);
//             physical_devices.set_len(len as usize);
//         }
//         physical_devices
//     };
//     physical_devices.get(0).map(|val| *val)
// }

// fn create_vk_device(
//     instance: vk::Instance,
//     extension_names: Vec<*const c_char>,
// ) -> Result<vk::Device, Error> {
//     let instance_pointers = fvk::instance_pointers(instance);
//     let physical_device = match get_vk_physical_device(instance)?;

//     let mut queue_family_count = unsafe {
//         create_from(|ptr| {
//             vk_i.GetPhysicalDeviceQueueFamilyProperties(physical_device, ptr, ptr::null_mut())
//         })
//     };
//     let mut queue_family_properties = Vec::with_capacity(queue_family_count as usize);
//     unsafe {
//         vk_i.GetPhysicalDeviceQueueFamilyProperties(
//             physical_device,
//             &mut queue_family_count,
//             queue_family_properties.as_mut_ptr(),
//         );
//         queue_family_properties.set_len(queue_family_count as usize);
//     }
//     if queue_family_count == 0 {
//         println!("no queue family available!");
//         return None;
//     }

//     let queue_priority: f32 = 1.0;
//     let queue_create_info = vk::DeviceQueueCreateInfo {
//         sType: vk::STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
//         pNext: ptr::null(),
//         flags: 0,
//         queueFamilyIndex: 0,
//         queueCount: 1,
//         pQueuePriorities: &queue_priority as *const f32,
//     };

//     let device = unsafe {
//         init(|ptr| {
//             let create_device_result = vk_i.CreateDevice(
//                 physical_device,
//                 &vk::DeviceCreateInfo {
//                     sType: vk::STRUCTURE_TYPE_DEVICE_CREATE_INFO,
//                     pNext: ptr::null(),
//                     flags: 0,
//                     queueCreateInfoCount: 1,
//                     pQueueCreateInfos: &queue_create_info as *const _,
//                     enabledLayerCount: 0,
//                     ppEnabledLayerNames: ptr::null(),
//                     enabledExtensionCount: extension_names.len() as u32,
//                     ppEnabledExtensionNames: extension_names.as_ptr(),
//                     pEnabledFeatures: ptr::null(),
//                 },
//                 ptr::null(),
//                 ptr,
//             );
//             assert!(create_device_result == vk::SUCCESS);
//         })
//     };
//     Some(device)
// }

// fn destroy_vk_device(instance: vk::Instance, device: vk::Device) {
//     let vk_i = super::instance_pointers(instance);
//     let vk_d = super::device_pointers(&vk_i, device);
//     unsafe {
//         vk_d.DestroyDevice(device, ptr::null());
//     }
// }
/*
// Simple offset_of macro akin to C++ offsetof
macro_rules! offset_of {
    ($base:path, $field:ident) => {{
        #[allow(unused_unsafe)]
        unsafe {
            let b: $base = mem::zeroed();
            (&b.$field as *const _ as isize) - (&b as *const _ as isize)
        }
    }};
}

/// Helper function for submitting command buffers. Immediately waits for the fence before the command buffer
/// is executed. That way we can delay the waiting for the fences by 1 frame which is good for performance.
/// Make sure to create the fence in a signaled state on the first use.
#[allow(clippy::too_many_arguments)]
pub fn record_submit_commandbuffer<F: FnOnce(&Device, vk::CommandBuffer)>(
    device: &Device,
    command_buffer: vk::CommandBuffer,
    command_buffer_reuse_fence: vk::Fence,
    submit_queue: vk::Queue,
    wait_mask: &[vk::PipelineStageFlags],
    wait_semaphores: &[vk::Semaphore],
    signal_semaphores: &[vk::Semaphore],
    f: F,
) {
    unsafe {
        device
            .wait_for_fences(&[command_buffer_reuse_fence], true, std::u64::MAX)
            .expect("Wait for fence failed.");

        device
            .reset_fences(&[command_buffer_reuse_fence])
            .expect("Reset fences failed.");

        device
            .reset_command_buffer(
                command_buffer,
                vk::CommandBufferResetFlags::RELEASE_RESOURCES,
            )
            .expect("Reset command buffer failed.");

        let command_buffer_begin_info = vk::CommandBufferBeginInfo::default()
            .flags(vk::CommandBufferUsageFlags::ONE_TIME_SUBMIT);

        device
            .begin_command_buffer(command_buffer, &command_buffer_begin_info)
            .expect("Begin commandbuffer");
        f(device, command_buffer);
        device
            .end_command_buffer(command_buffer)
            .expect("End commandbuffer");

        let command_buffers = vec![command_buffer];

        let submit_info = vk::SubmitInfo::default()
            .wait_semaphores(wait_semaphores)
            .wait_dst_stage_mask(wait_mask)
            .command_buffers(&command_buffers)
            .signal_semaphores(signal_semaphores);

        device
            .queue_submit(submit_queue, &[submit_info], command_buffer_reuse_fence)
            .expect("queue submit failed.");
    }
}

*/

unsafe extern "system" fn vulkan_debug_callback(
    message_severity: vk::DebugUtilsMessageSeverityFlagsEXT,
    message_type: vk::DebugUtilsMessageTypeFlagsEXT,
    p_callback_data: *const vk::DebugUtilsMessengerCallbackDataEXT,
    _user_data: *mut std::os::raw::c_void,
) -> vk::Bool32 {
    let callback_data = *p_callback_data;
    let message_id_number: i32 = callback_data.message_id_number as i32;

    let message_id_name = if callback_data.p_message_id_name.is_null() {
        Cow::from("")
    } else {
        CStr::from_ptr(callback_data.p_message_id_name).to_string_lossy()
    };

    let message = if callback_data.p_message.is_null() {
        Cow::from("")
    } else {
        CStr::from_ptr(callback_data.p_message).to_string_lossy()
    };

    println!(
        "{:?}:\n{:?} [{} ({})] : {}\n",
        message_severity,
        message_type,
        message_id_name,
        &message_id_number.to_string(),
        message,
    );

    vk::FALSE
}

// pub fn find_memorytype_index(
//     memory_req: &vk::MemoryRequirements,
//     memory_prop: &vk::PhysicalDeviceMemoryProperties,
//     flags: vk::MemoryPropertyFlags,
// ) -> Option<u32> {
//     memory_prop.memory_types[..memory_prop.memory_type_count as _]
//         .iter()
//         .enumerate()
//         .find(|(index, memory_type)| {
//             (1 << index) & memory_req.memory_type_bits != 0
//                 && memory_type.property_flags & flags == flags
//         })
//         .map(|(index, _memory_type)| index as _)
// }

pub struct VkRender {
    pub entry: ash::Entry,
    pub instance: ash::Instance,
    pub device: ash::Device,
    // pub surface_loader: Surface,
    // pub swapchain_loader: Swapchain,
    // pub debug_utils_loader: DebugUtils,
    // pub debug_call_back: vk::DebugUtilsMessengerEXT,

    // pub pdevice: vk::PhysicalDevice,
    // pub device_memory_properties: vk::PhysicalDeviceMemoryProperties,
    // pub queue_family_index: u32,
    // pub present_queue: vk::Queue,

    // pub surface: vk::SurfaceKHR,
    // pub surface_format: vk::SurfaceFormatKHR,
    // pub surface_resolution: vk::Extent2D,

    // pub swapchain: vk::SwapchainKHR,
    // pub present_images: Vec<vk::Image>,
    // pub present_image_views: Vec<vk::ImageView>,

    // pub pool: vk::CommandPool,
    // pub draw_command_buffer: vk::CommandBuffer,
    // pub setup_command_buffer: vk::CommandBuffer,

    // pub depth_image: vk::Image,
    // pub depth_image_view: vk::ImageView,
    // pub depth_image_memory: vk::DeviceMemory,

    // pub present_complete_semaphore: vk::Semaphore,
    // pub rendering_complete_semaphore: vk::Semaphore,

    // pub draw_commands_reuse_fence: vk::Fence,
    // pub setup_commands_reuse_fence: vk::Fence,
}

impl VkRender {
    // pub fn render_loop<F: Fn()>(&self, f: F) {
    //     self.event_loop
    //         .borrow_mut()
    //         .run_return(|event, _, control_flow| {
    //             *control_flow = ControlFlow::Poll;
    //             match event {
    //                 Event::WindowEvent {
    //                     event:
    //                         WindowEvent::CloseRequested
    //                         | WindowEvent::KeyboardInput {
    //                             input:
    //                                 KeyboardInput {
    //                                     state: ElementState::Pressed,
    //                                     virtual_keycode: Some(VirtualKeyCode::Escape),
    //                                     ..
    //                                 },
    //                             ..
    //                         },
    //                     ..
    //                 } => *control_flow = ControlFlow::Exit,
    //                 Event::MainEventsCleared => f(),
    //                 _ => (),
    //             }
    //         });
    // }

    pub fn new(_window_width: u32, _window_height: u32) -> Result<(), Error> {
        unsafe {
            // let event_loop = EventLoop::new();
            // let window = WindowBuilder::new()
            //     .with_title("Ash - Example")
            //     .with_inner_size(winit::dpi::LogicalSize::new(
            //         f64::from(window_width),
            //         f64::from(window_height),
            //     ))
            //     .build(&event_loop)
            //     .unwrap();
            let entry = ash::Entry::load()?;
            let app_name = CStr::from_bytes_with_nul_unchecked(b"flatland-view-provider\0");

            let layer_names = [CStr::from_bytes_with_nul_unchecked(
                b"VK_LAYER_KHRONOS_validation\0",
            )];
            let layers_names_raw: Vec<*const c_char> = layer_names
                .iter()
                .map(|raw_name| raw_name.as_ptr())
                .collect();

            let extension_names = vec![DebugUtils::name().as_ptr()];

            let appinfo = vk::ApplicationInfo::builder()
                .application_name(app_name)
                .application_version(0)
                .engine_name(app_name)
                .engine_version(0)
                .api_version(vk::make_api_version(0, 1, 0, 0))
                .build();

            let create_info = vk::InstanceCreateInfo::builder()
                .application_info(&appinfo)
                .enabled_layer_names(&layers_names_raw)
                .enabled_extension_names(&extension_names)
                .build();

            let instance: ash::Instance = entry
                .create_instance(&create_info, None)
                .expect("Instance creation error");

            let debug_info = vk::DebugUtilsMessengerCreateInfoEXT::builder()
                .message_severity(
                    vk::DebugUtilsMessageSeverityFlagsEXT::ERROR
                        | vk::DebugUtilsMessageSeverityFlagsEXT::WARNING
                        | vk::DebugUtilsMessageSeverityFlagsEXT::INFO,
                )
                .message_type(
                    vk::DebugUtilsMessageTypeFlagsEXT::GENERAL
                        | vk::DebugUtilsMessageTypeFlagsEXT::VALIDATION
                        | vk::DebugUtilsMessageTypeFlagsEXT::PERFORMANCE,
                )
                .pfn_user_callback(Some(vulkan_debug_callback));

            let debug_utils_loader = DebugUtils::new(&entry, &instance);
            let _debug_call_back = debug_utils_loader
                .create_debug_utils_messenger(&debug_info, None)
                .unwrap();
            // let surface = ash_window::create_surface(&entry, &instance, &window, None).unwrap();
            let pdevices = instance
                .enumerate_physical_devices()
                .expect("Physical device error");
            assert!(pdevices.len() > 0);
            let pdevice_index = 0;
            let pdevice = pdevices[pdevice_index];
            // let surface_loader = Surface::new(&entry, &instance);
            // let (pdevice, queue_family_index) = pdevices
            //     .iter()
            //     .find_map(|pdevice| {
            //         instance
            //             .get_physical_device_queue_family_properties(*pdevice)
            //             .iter()
            //             .enumerate()
            //             .find_map(|(index, info)| {
            //                 let supports_graphic_and_surface =
            //                     info.queue_flags.contains(vk::QueueFlags::GRAPHICS)
            //                         && surface_loader
            //                             .get_physical_device_surface_support(
            //                                 *pdevice,
            //                                 index as u32,
            //                                 surface,
            //                             )
            //                             .unwrap();
            //                 if supports_graphic_and_surface {
            //                     Some((*pdevice, index))
            //                 } else {
            //                     None
            //                 }
            //             })
            //     })
            //     .expect("Couldn't find suitable device.");
            // let queue_family_index = queue_family_index as u32;
            let queue_family_index = 0;
            // let device_extension_names_raw = [Swapchain::name().as_ptr()];
            let features = vk::PhysicalDeviceFeatures::builder()
                .shader_clip_distance(true).
                build();
            //     shader_clip_distance: 1,
            //     ..Default::default()
            // };
            let priorities = [1.0];

            let queue_info = vk::DeviceQueueCreateInfo::builder()
                .queue_family_index(queue_family_index)
                .queue_priorities(&priorities)
                .build();

            let device_create_info = vk::DeviceCreateInfo::builder()
                .queue_create_infos(std::slice::from_ref(&queue_info))
                // .enabled_extension_names(&device_extension_names_raw)
                .enabled_features(&features)
                .build();

            let _device = instance
                .create_device(pdevice, &device_create_info, None)?;

        //     let present_queue = device.get_device_queue(queue_family_index as u32, 0);

        //     let surface_format = surface_loader
        //         .get_physical_device_surface_formats(pdevice, surface)
        //         .unwrap()[0];

        //     let surface_capabilities = surface_loader
        //         .get_physical_device_surface_capabilities(pdevice, surface)
        //         .unwrap();
        //     let mut desired_image_count = surface_capabilities.min_image_count + 1;
        //     if surface_capabilities.max_image_count > 0
        //         && desired_image_count > surface_capabilities.max_image_count
        //     {
        //         desired_image_count = surface_capabilities.max_image_count;
        //     }
        //     let surface_resolution = match surface_capabilities.current_extent.width {
        //         std::u32::MAX => vk::Extent2D {
        //             width: window_width,
        //             height: window_height,
        //         },
        //         _ => surface_capabilities.current_extent,
        //     };
        //     let pre_transform = if surface_capabilities
        //         .supported_transforms
        //         .contains(vk::SurfaceTransformFlagsKHR::IDENTITY)
        //     {
        //         vk::SurfaceTransformFlagsKHR::IDENTITY
        //     } else {
        //         surface_capabilities.current_transform
        //     };
        //     let present_modes = surface_loader
        //         .get_physical_device_surface_present_modes(pdevice, surface)
        //         .unwrap();
        //     let present_mode = present_modes
        //         .iter()
        //         .cloned()
        //         .find(|&mode| mode == vk::PresentModeKHR::MAILBOX)
        //         .unwrap_or(vk::PresentModeKHR::FIFO);
        //     let swapchain_loader = Swapchain::new(&instance, &device);

        //     let swapchain_create_info = vk::SwapchainCreateInfoKHR::default()
        //         .surface(surface)
        //         .min_image_count(desired_image_count)
        //         .image_color_space(surface_format.color_space)
        //         .image_format(surface_format.format)
        //         .image_extent(surface_resolution)
        //         .image_usage(vk::ImageUsageFlags::COLOR_ATTACHMENT)
        //         .image_sharing_mode(vk::SharingMode::EXCLUSIVE)
        //         .pre_transform(pre_transform)
        //         .composite_alpha(vk::CompositeAlphaFlagsKHR::OPAQUE)
        //         .present_mode(present_mode)
        //         .clipped(true)
        //         .image_array_layers(1);

        //     let swapchain = swapchain_loader
        //         .create_swapchain(&swapchain_create_info, None)
        //         .unwrap();

        //     let pool_create_info = vk::CommandPoolCreateInfo::default()
        //         .flags(vk::CommandPoolCreateFlags::RESET_COMMAND_BUFFER)
        //         .queue_family_index(queue_family_index);

        //     let pool = device.create_command_pool(&pool_create_info, None).unwrap();

        //     let command_buffer_allocate_info = vk::CommandBufferAllocateInfo::default()
        //         .command_buffer_count(2)
        //         .command_pool(pool)
        //         .level(vk::CommandBufferLevel::PRIMARY);

        //     let command_buffers = device
        //         .allocate_command_buffers(&command_buffer_allocate_info)
        //         .unwrap();
        //     let setup_command_buffer = command_buffers[0];
        //     let draw_command_buffer = command_buffers[1];

        //     let present_images = swapchain_loader.get_swapchain_images(swapchain).unwrap();
        //     let present_image_views: Vec<vk::ImageView> = present_images
        //         .iter()
        //         .map(|&image| {
        //             let create_view_info = vk::ImageViewCreateInfo::default()
        //                 .view_type(vk::ImageViewType::TYPE_2D)
        //                 .format(surface_format.format)
        //                 .components(vk::ComponentMapping {
        //                     r: vk::ComponentSwizzle::R,
        //                     g: vk::ComponentSwizzle::G,
        //                     b: vk::ComponentSwizzle::B,
        //                     a: vk::ComponentSwizzle::A,
        //                 })
        //                 .subresource_range(vk::ImageSubresourceRange {
        //                     aspect_mask: vk::ImageAspectFlags::COLOR,
        //                     base_mip_level: 0,
        //                     level_count: 1,
        //                     base_array_layer: 0,
        //                     layer_count: 1,
        //                 })
        //                 .image(image);
        //             device.create_image_view(&create_view_info, None).unwrap()
        //         })
        //         .collect();
        //     let device_memory_properties = instance.get_physical_device_memory_properties(pdevice);
        //     let depth_image_create_info = vk::ImageCreateInfo::default()
        //         .image_type(vk::ImageType::TYPE_2D)
        //         .format(vk::Format::D16_UNORM)
        //         .extent(surface_resolution.into())
        //         .mip_levels(1)
        //         .array_layers(1)
        //         .samples(vk::SampleCountFlags::TYPE_1)
        //         .tiling(vk::ImageTiling::OPTIMAL)
        //         .usage(vk::ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT)
        //         .sharing_mode(vk::SharingMode::EXCLUSIVE);

        //     let depth_image = device.create_image(&depth_image_create_info, None).unwrap();
        //     let depth_image_memory_req = device.get_image_memory_requirements(depth_image);
        //     let depth_image_memory_index = find_memorytype_index(
        //         &depth_image_memory_req,
        //         &device_memory_properties,
        //         vk::MemoryPropertyFlags::DEVICE_LOCAL,
        //     )
        //     .expect("Unable to find suitable memory index for depth image.");

        //     let depth_image_allocate_info = vk::MemoryAllocateInfo::default()
        //         .allocation_size(depth_image_memory_req.size)
        //         .memory_type_index(depth_image_memory_index);

        //     let depth_image_memory = device
        //         .allocate_memory(&depth_image_allocate_info, None)
        //         .unwrap();

        //     device
        //         .bind_image_memory(depth_image, depth_image_memory, 0)
        //         .expect("Unable to bind depth image memory");

        //     let fence_create_info =
        //         vk::FenceCreateInfo::default().flags(vk::FenceCreateFlags::SIGNALED);

        //     let draw_commands_reuse_fence = device
        //         .create_fence(&fence_create_info, None)
        //         .expect("Create fence failed.");
        //     let setup_commands_reuse_fence = device
        //         .create_fence(&fence_create_info, None)
        //         .expect("Create fence failed.");

        //     record_submit_commandbuffer(
        //         &device,
        //         setup_command_buffer,
        //         setup_commands_reuse_fence,
        //         present_queue,
        //         &[],
        //         &[],
        //         &[],
        //         |device, setup_command_buffer| {
        //             let layout_transition_barriers = vk::ImageMemoryBarrier::default()
        //                 .image(depth_image)
        //                 .dst_access_mask(
        //                     vk::AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ
        //                         | vk::AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE,
        //                 )
        //                 .new_layout(vk::ImageLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL)
        //                 .old_layout(vk::ImageLayout::UNDEFINED)
        //                 .subresource_range(
        //                     vk::ImageSubresourceRange::default()
        //                         .aspect_mask(vk::ImageAspectFlags::DEPTH)
        //                         .layer_count(1)
        //                         .level_count(1),
        //                 );

        //             device.cmd_pipeline_barrier(
        //                 setup_command_buffer,
        //                 vk::PipelineStageFlags::BOTTOM_OF_PIPE,
        //                 vk::PipelineStageFlags::LATE_FRAGMENT_TESTS,
        //                 vk::DependencyFlags::empty(),
        //                 &[],
        //                 &[],
        //                 &[layout_transition_barriers],
        //             );
        //         },
        //     );

        //     let depth_image_view_info = vk::ImageViewCreateInfo::default()
        //         .subresource_range(
        //             vk::ImageSubresourceRange::default()
        //                 .aspect_mask(vk::ImageAspectFlags::DEPTH)
        //                 .level_count(1)
        //                 .layer_count(1),
        //         )
        //         .image(depth_image)
        //         .format(depth_image_create_info.format)
        //         .view_type(vk::ImageViewType::TYPE_2D);

        //     let depth_image_view = device
        //         .create_image_view(&depth_image_view_info, None)
        //         .unwrap();

        //     let semaphore_create_info = vk::SemaphoreCreateInfo::default();

        //     let present_complete_semaphore = device
        //         .create_semaphore(&semaphore_create_info, None)
        //         .unwrap();
        //     let rendering_complete_semaphore = device
        //         .create_semaphore(&semaphore_create_info, None)
        //         .unwrap();

        //     VkRender {
        //         event_loop: RefCell::new(event_loop),
        //         entry,
        //         instance,
        //         device,
        //         queue_family_index,
        //         pdevice,
        //         device_memory_properties,
        //         window,
        //         surface_loader,
        //         surface_format,
        //         present_queue,
        //         surface_resolution,
        //         swapchain_loader,
        //         swapchain,
        //         present_images,
        //         present_image_views,
        //         pool,
        //         draw_command_buffer,
        //         setup_command_buffer,
        //         depth_image,
        //         depth_image_view,
        //         present_complete_semaphore,
        //         rendering_complete_semaphore,
        //         draw_commands_reuse_fence,
        //         setup_commands_reuse_fence,
        //         surface,
        //         debug_call_back,
        //         debug_utils_loader,
        //         depth_image_memory,
        //     }
        }
        Ok(())
    }
}

impl std::ops::Drop for VkRender {
    fn drop(&mut self) {
        // unsafe {
            // self.device.device_wait_idle().unwrap();
            // self.device
            //     .destroy_semaphore(self.present_complete_semaphore, None);
            // self.device
            //     .destroy_semaphore(self.rendering_complete_semaphore, None);
            // self.device
            //     .destroy_fence(self.draw_commands_reuse_fence, None);
            // self.device
            //     .destroy_fence(self.setup_commands_reuse_fence, None);
            // self.device.free_memory(self.depth_image_memory, None);
            // self.device.destroy_image_view(self.depth_image_view, None);
            // self.device.destroy_image(self.depth_image, None);
            // for &image_view in self.present_image_views.iter() {
            //     self.device.destroy_image_view(image_view, None);
            // }
            // self.device.destroy_command_pool(self.pool, None);
            // self.swapchain_loader
            //     .destroy_swapchain(self.swapchain, None);
            // self.device.destroy_device(None);
            // self.surface_loader.destroy_surface(self.surface, None);
            // self.debug_utils_loader
            //     .destroy_debug_utils_messenger(self.debug_call_back, None);
            // self.instance.destroy_instance(None);
        // }
    }
}


// #[derive(Clone, Debug, Copy)]
// struct Vertex {
//     pos: [f32; 4],
//     color: [f32; 4],
// }


fn render() {
    // unsafe {
        VkRender::new(1920, 1080).expect("failed to create VkRenderer");
        // let renderpass_attachments = [
        //     vk::AttachmentDescription {
        //         format: base.surface_format.format,
        //         samples: vk::SampleCountFlags::TYPE_1,
        //         load_op: vk::AttachmentLoadOp::CLEAR,
        //         store_op: vk::AttachmentStoreOp::STORE,
        //         final_layout: vk::ImageLayout::PRESENT_SRC_KHR,
        //         ..Default::default()
        //     },
        //     vk::AttachmentDescription {
        //         format: vk::Format::D16_UNORM,
        //         samples: vk::SampleCountFlags::TYPE_1,
        //         load_op: vk::AttachmentLoadOp::CLEAR,
        //         initial_layout: vk::ImageLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
        //         final_layout: vk::ImageLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
        //         ..Default::default()
        //     },
        // ];
        // let color_attachment_refs = [vk::AttachmentReference {
        //     attachment: 0,
        //     layout: vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL,
        // }];
        // let depth_attachment_ref = vk::AttachmentReference {
        //     attachment: 1,
        //     layout: vk::ImageLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
        // };
        // let dependencies = [vk::SubpassDependency {
        //     src_subpass: vk::SUBPASS_EXTERNAL,
        //     src_stage_mask: vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT,
        //     dst_access_mask: vk::AccessFlags::COLOR_ATTACHMENT_READ
        //         | vk::AccessFlags::COLOR_ATTACHMENT_WRITE,
        //     dst_stage_mask: vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT,
        //     ..Default::default()
        // }];

        // let subpass = vk::SubpassDescription::default()
        //     .color_attachments(&color_attachment_refs)
        //     .depth_stencil_attachment(&depth_attachment_ref)
        //     .pipeline_bind_point(vk::PipelineBindPoint::GRAPHICS);

        // let renderpass_create_info = vk::RenderPassCreateInfo::default()
        //     .attachments(&renderpass_attachments)
        //     .subpasses(std::slice::from_ref(&subpass))
        //     .dependencies(&dependencies);

        // let renderpass = base
        //     .device
        //     .create_render_pass(&renderpass_create_info, None)
        //     .unwrap();

        // let framebuffers: Vec<vk::Framebuffer> = base
        //     .present_image_views
        //     .iter()
        //     .map(|&present_image_view| {
        //         let framebuffer_attachments = [present_image_view, base.depth_image_view];
        //         let frame_buffer_create_info = vk::FramebufferCreateInfo::default()
        //             .render_pass(renderpass)
        //             .attachments(&framebuffer_attachments)
        //             .width(base.surface_resolution.width)
        //             .height(base.surface_resolution.height)
        //             .layers(1);

        //         base.device
        //             .create_framebuffer(&frame_buffer_create_info, None)
        //             .unwrap()
        //     })
        //     .collect();

        // let index_buffer_data = [0u32, 1, 2];
        // let index_buffer_info = vk::BufferCreateInfo::default()
        //     .size(std::mem::size_of_val(&index_buffer_data) as u64)
        //     .usage(vk::BufferUsageFlags::INDEX_BUFFER)
        //     .sharing_mode(vk::SharingMode::EXCLUSIVE);

        // let index_buffer = base.device.create_buffer(&index_buffer_info, None).unwrap();
        // let index_buffer_memory_req = base.device.get_buffer_memory_requirements(index_buffer);
        // let index_buffer_memory_index = find_memorytype_index(
        //     &index_buffer_memory_req,
        //     &base.device_memory_properties,
        //     vk::MemoryPropertyFlags::HOST_VISIBLE | vk::MemoryPropertyFlags::HOST_COHERENT,
        // )
        // .expect("Unable to find suitable memorytype for the index buffer.");

        // let index_allocate_info = vk::MemoryAllocateInfo {
        //     allocation_size: index_buffer_memory_req.size,
        //     memory_type_index: index_buffer_memory_index,
        //     ..Default::default()
        // };
        // let index_buffer_memory = base
        //     .device
        //     .allocate_memory(&index_allocate_info, None)
        //     .unwrap();
        // let index_ptr = base
        //     .device
        //     .map_memory(
        //         index_buffer_memory,
        //         0,
        //         index_buffer_memory_req.size,
        //         vk::MemoryMapFlags::empty(),
        //     )
        //     .unwrap();
        // let mut index_slice = Align::new(
        //     index_ptr,
        //     align_of::<u32>() as u64,
        //     index_buffer_memory_req.size,
        // );
        // index_slice.copy_from_slice(&index_buffer_data);
        // base.device.unmap_memory(index_buffer_memory);
        // base.device
        //     .bind_buffer_memory(index_buffer, index_buffer_memory, 0)
        //     .unwrap();

        // let vertex_input_buffer_info = vk::BufferCreateInfo {
        //     size: 3 * std::mem::size_of::<Vertex>() as u64,
        //     usage: vk::BufferUsageFlags::VERTEX_BUFFER,
        //     sharing_mode: vk::SharingMode::EXCLUSIVE,
        //     ..Default::default()
        // };

        // let vertex_input_buffer = base
        //     .device
        //     .create_buffer(&vertex_input_buffer_info, None)
        //     .unwrap();

        // let vertex_input_buffer_memory_req = base
        //     .device
        //     .get_buffer_memory_requirements(vertex_input_buffer);

        // let vertex_input_buffer_memory_index = find_memorytype_index(
        //     &vertex_input_buffer_memory_req,
        //     &base.device_memory_properties,
        //     vk::MemoryPropertyFlags::HOST_VISIBLE | vk::MemoryPropertyFlags::HOST_COHERENT,
        // )
        // .expect("Unable to find suitable memorytype for the vertex buffer.");

        // let vertex_buffer_allocate_info = vk::MemoryAllocateInfo {
        //     allocation_size: vertex_input_buffer_memory_req.size,
        //     memory_type_index: vertex_input_buffer_memory_index,
        //     ..Default::default()
        // };

        // let vertex_input_buffer_memory = base
        //     .device
        //     .allocate_memory(&vertex_buffer_allocate_info, None)
        //     .unwrap();

        // let vertices = [
        //     Vertex {
        //         pos: [-1.0, 1.0, 0.0, 1.0],
        //         color: [0.0, 1.0, 0.0, 1.0],
        //     },
        //     Vertex {
        //         pos: [1.0, 1.0, 0.0, 1.0],
        //         color: [0.0, 0.0, 1.0, 1.0],
        //     },
        //     Vertex {
        //         pos: [0.0, -1.0, 0.0, 1.0],
        //         color: [1.0, 0.0, 0.0, 1.0],
        //     },
        // ];

        // let vert_ptr = base
        //     .device
        //     .map_memory(
        //         vertex_input_buffer_memory,
        //         0,
        //         vertex_input_buffer_memory_req.size,
        //         vk::MemoryMapFlags::empty(),
        //     )
        //     .unwrap();

        // let mut vert_align = Align::new(
        //     vert_ptr,
        //     align_of::<Vertex>() as u64,
        //     vertex_input_buffer_memory_req.size,
        // );
        // vert_align.copy_from_slice(&vertices);
        // base.device.unmap_memory(vertex_input_buffer_memory);
        // base.device
        //     .bind_buffer_memory(vertex_input_buffer, vertex_input_buffer_memory, 0)
        //     .unwrap();
        // let mut vertex_spv_file =
        //     Cursor::new(&include_bytes!("../../shader/triangle/vert.spv")[..]);
        // let mut frag_spv_file = Cursor::new(&include_bytes!("../../shader/triangle/frag.spv")[..]);

        // let vertex_code =
        //     read_spv(&mut vertex_spv_file).expect("Failed to read vertex shader spv file");
        // let vertex_shader_info = vk::ShaderModuleCreateInfo::default().code(&vertex_code);

        // let frag_code =
        //     read_spv(&mut frag_spv_file).expect("Failed to read fragment shader spv file");
        // let frag_shader_info = vk::ShaderModuleCreateInfo::default().code(&frag_code);

        // let vertex_shader_module = base
        //     .device
        //     .create_shader_module(&vertex_shader_info, None)
        //     .expect("Vertex shader module error");

        // let fragment_shader_module = base
        //     .device
        //     .create_shader_module(&frag_shader_info, None)
        //     .expect("Fragment shader module error");

        // let layout_create_info = vk::PipelineLayoutCreateInfo::default();

        // let pipeline_layout = base
        //     .device
        //     .create_pipeline_layout(&layout_create_info, None)
        //     .unwrap();

        // let shader_entry_name = CStr::from_bytes_with_nul_unchecked(b"main\0");
        // let shader_stage_create_infos = [
        //     vk::PipelineShaderStageCreateInfo {
        //         module: vertex_shader_module,
        //         p_name: shader_entry_name.as_ptr(),
        //         stage: vk::ShaderStageFlags::VERTEX,
        //         ..Default::default()
        //     },
        //     vk::PipelineShaderStageCreateInfo {
        //         s_type: vk::StructureType::PIPELINE_SHADER_STAGE_CREATE_INFO,
        //         module: fragment_shader_module,
        //         p_name: shader_entry_name.as_ptr(),
        //         stage: vk::ShaderStageFlags::FRAGMENT,
        //         ..Default::default()
        //     },
        // ];
        // let vertex_input_binding_descriptions = [vk::VertexInputBindingDescription {
        //     binding: 0,
        //     stride: mem::size_of::<Vertex>() as u32,
        //     input_rate: vk::VertexInputRate::VERTEX,
        // }];
        // let vertex_input_attribute_descriptions = [
        //     vk::VertexInputAttributeDescription {
        //         location: 0,
        //         binding: 0,
        //         format: vk::Format::R32G32B32A32_SFLOAT,
        //         offset: offset_of!(Vertex, pos) as u32,
        //     },
        //     vk::VertexInputAttributeDescription {
        //         location: 1,
        //         binding: 0,
        //         format: vk::Format::R32G32B32A32_SFLOAT,
        //         offset: offset_of!(Vertex, color) as u32,
        //     },
        // ];

        // let vertex_input_state_info = vk::PipelineVertexInputStateCreateInfo::default()
        //     .vertex_attribute_descriptions(&vertex_input_attribute_descriptions)
        //     .vertex_binding_descriptions(&vertex_input_binding_descriptions);
        // let vertex_input_assembly_state_info = vk::PipelineInputAssemblyStateCreateInfo {
        //     topology: vk::PrimitiveTopology::TRIANGLE_LIST,
        //     ..Default::default()
        // };
        // let viewports = [vk::Viewport {
        //     x: 0.0,
        //     y: 0.0,
        //     width: base.surface_resolution.width as f32,
        //     height: base.surface_resolution.height as f32,
        //     min_depth: 0.0,
        //     max_depth: 1.0,
        // }];
        // let scissors = [base.surface_resolution.into()];
        // let viewport_state_info = vk::PipelineViewportStateCreateInfo::default()
        //     .scissors(&scissors)
        //     .viewports(&viewports);

        // let rasterization_info = vk::PipelineRasterizationStateCreateInfo {
        //     front_face: vk::FrontFace::COUNTER_CLOCKWISE,
        //     line_width: 1.0,
        //     polygon_mode: vk::PolygonMode::FILL,
        //     ..Default::default()
        // };
        // let multisample_state_info = vk::PipelineMultisampleStateCreateInfo {
        //     rasterization_samples: vk::SampleCountFlags::TYPE_1,
        //     ..Default::default()
        // };
        // let noop_stencil_state = vk::StencilOpState {
        //     fail_op: vk::StencilOp::KEEP,
        //     pass_op: vk::StencilOp::KEEP,
        //     depth_fail_op: vk::StencilOp::KEEP,
        //     compare_op: vk::CompareOp::ALWAYS,
        //     ..Default::default()
        // };
        // let depth_state_info = vk::PipelineDepthStencilStateCreateInfo {
        //     depth_test_enable: 1,
        //     depth_write_enable: 1,
        //     depth_compare_op: vk::CompareOp::LESS_OR_EQUAL,
        //     front: noop_stencil_state,
        //     back: noop_stencil_state,
        //     max_depth_bounds: 1.0,
        //     ..Default::default()
        // };
        // let color_blend_attachment_states = [vk::PipelineColorBlendAttachmentState {
        //     blend_enable: 0,
        //     src_color_blend_factor: vk::BlendFactor::SRC_COLOR,
        //     dst_color_blend_factor: vk::BlendFactor::ONE_MINUS_DST_COLOR,
        //     color_blend_op: vk::BlendOp::ADD,
        //     src_alpha_blend_factor: vk::BlendFactor::ZERO,
        //     dst_alpha_blend_factor: vk::BlendFactor::ZERO,
        //     alpha_blend_op: vk::BlendOp::ADD,
        //     color_write_mask: vk::ColorComponentFlags::RGBA,
        // }];
        // let color_blend_state = vk::PipelineColorBlendStateCreateInfo::default()
        //     .logic_op(vk::LogicOp::CLEAR)
        //     .attachments(&color_blend_attachment_states);

        // let dynamic_state = [vk::DynamicState::VIEWPORT, vk::DynamicState::SCISSOR];
        // let dynamic_state_info =
        //     vk::PipelineDynamicStateCreateInfo::default().dynamic_states(&dynamic_state);

        // let graphic_pipeline_info = vk::GraphicsPipelineCreateInfo::default()
        //     .stages(&shader_stage_create_infos)
        //     .vertex_input_state(&vertex_input_state_info)
        //     .input_assembly_state(&vertex_input_assembly_state_info)
        //     .viewport_state(&viewport_state_info)
        //     .rasterization_state(&rasterization_info)
        //     .multisample_state(&multisample_state_info)
        //     .depth_stencil_state(&depth_state_info)
        //     .color_blend_state(&color_blend_state)
        //     .dynamic_state(&dynamic_state_info)
        //     .layout(pipeline_layout)
        //     .render_pass(renderpass);

        // let graphics_pipelines = base
        //     .device
        //     .create_graphics_pipelines(vk::PipelineCache::null(), &[graphic_pipeline_info], None)
        //     .expect("Unable to create graphics pipeline");

        // let graphic_pipeline = graphics_pipelines[0];

        // base.render_loop(|| {
        //     let (present_index, _) = base
        //         .swapchain_loader
        //         .acquire_next_image(
        //             base.swapchain,
        //             std::u64::MAX,
        //             base.present_complete_semaphore,
        //             vk::Fence::null(),
        //         )
        //         .unwrap();
        //     let clear_values = [
        //         vk::ClearValue {
        //             color: vk::ClearColorValue {
        //                 float32: [0.0, 0.0, 0.0, 0.0],
        //             },
        //         },
        //         vk::ClearValue {
        //             depth_stencil: vk::ClearDepthStencilValue {
        //                 depth: 1.0,
        //                 stencil: 0,
        //             },
        //         },
        //     ];

        //     let render_pass_begin_info = vk::RenderPassBeginInfo::default()
        //         .render_pass(renderpass)
        //         .framebuffer(framebuffers[present_index as usize])
        //         .render_area(base.surface_resolution.into())
        //         .clear_values(&clear_values);

        //     record_submit_commandbuffer(
        //         &base.device,
        //         base.draw_command_buffer,
        //         base.draw_commands_reuse_fence,
        //         base.present_queue,
        //         &[vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT],
        //         &[base.present_complete_semaphore],
        //         &[base.rendering_complete_semaphore],
        //         |device, draw_command_buffer| {
        //             device.cmd_begin_render_pass(
        //                 draw_command_buffer,
        //                 &render_pass_begin_info,
        //                 vk::SubpassContents::INLINE,
        //             );
        //             device.cmd_bind_pipeline(
        //                 draw_command_buffer,
        //                 vk::PipelineBindPoint::GRAPHICS,
        //                 graphic_pipeline,
        //             );
        //             device.cmd_set_viewport(draw_command_buffer, 0, &viewports);
        //             device.cmd_set_scissor(draw_command_buffer, 0, &scissors);
        //             device.cmd_bind_vertex_buffers(
        //                 draw_command_buffer,
        //                 0,
        //                 &[vertex_input_buffer],
        //                 &[0],
        //             );
        //             device.cmd_bind_index_buffer(
        //                 draw_command_buffer,
        //                 index_buffer,
        //                 0,
        //                 vk::IndexType::UINT32,
        //             );
        //             device.cmd_draw_indexed(
        //                 draw_command_buffer,
        //                 index_buffer_data.len() as u32,
        //                 1,
        //                 0,
        //                 0,
        //                 1,
        //             );
        //             // Or draw without the index buffer
        //             // device.cmd_draw(draw_command_buffer, 3, 1, 0, 0);
        //             device.cmd_end_render_pass(draw_command_buffer);
        //         },
        //     );
        //     //let mut present_info_err = mem::zeroed();
        //     let wait_semaphors = [base.rendering_complete_semaphore];
        //     let swapchains = [base.swapchain];
        //     let image_indices = [present_index];
        //     let present_info = vk::PresentInfoKHR::default()
        //         .wait_semaphores(&wait_semaphors) // &base.rendering_complete_semaphore)
        //         .swapchains(&swapchains)
        //         .image_indices(&image_indices);

        //     base.swapchain_loader
        //         .queue_present(base.present_queue, &present_info)
        //         .unwrap();
        // });

        // base.device.device_wait_idle().unwrap();
        // for pipeline in graphics_pipelines {
        //     base.device.destroy_pipeline(pipeline, None);
        // }
        // base.device.destroy_pipeline_layout(pipeline_layout, None);
        // base.device
        //     .destroy_shader_module(vertex_shader_module, None);
        // base.device
        //     .destroy_shader_module(fragment_shader_module, None);
        // base.device.free_memory(index_buffer_memory, None);
        // base.device.destroy_buffer(index_buffer, None);
        // base.device.free_memory(vertex_input_buffer_memory, None);
        // base.device.destroy_buffer(vertex_input_buffer, None);
        // for framebuffer in framebuffers {
        //     base.device.destroy_framebuffer(framebuffer, None);
        // }
        // base.device.destroy_render_pass(renderpass, None);
    // }
}

pub fn init() {
    render();
    // let instance = create_vk_instance();
    // let physical_device = get_vk_physical_device(instance);

    // assert!(physical_device.is_some());
    // destroy_vk_device(instance, physical_device.unwrap());
}