monolith

use crate::Error;

use ash::vk;

use gpu_allocator::vulkan::{Allocator, AllocatorCreateDesc};

use std::sync::Mutex;

/// Everything that must outlive every Vulkan object the renderer hands out.

/// Fields drop in declaration order, so the allocator frees its memory before

/// the device is destroyed.

pub(crate) struct Shared {

    pub allocator: Mutex<Allocator>,

    pub device: Device,

}

pub(crate) struct Device {

    pub _entry: ash::Entry,

    pub instance: ash::Instance,

    #[expect(

        dead_code,

        reason = "dmabuf import queries format properties through it"

    )]

    pub physical: vk::PhysicalDevice,

    pub device: ash::Device,

    pub queue: Mutex<vk::Queue>,

    pub queue_family: u32,

    pub push_descriptor: ash::khr::push_descriptor::Device,

    pub name: String,

}

impl Drop for Device {

    fn drop(&mut self) {

        unsafe {

            let _ = self.device.device_wait_idle();

            self.device.destroy_device(None);

            self.instance.destroy_instance(None);

        }

    }

}

impl Shared {

    /// Opens the first suitable device, or the one whose name contains

    /// `MONOLITH_VK_DEVICE` when that is set.

    pub fn new() -> Result<Self, Error> {

        let entry = unsafe { ash::Entry::load()? };

        let app = vk::ApplicationInfo::default()

            .application_name(c"monolith")

            .engine_name(c"monolith")

            .api_version(vk::API_VERSION_1_3);

        let instance = unsafe {

            entry.create_instance(

                &vk::InstanceCreateInfo::default().application_info(&app),

                None,

            )?

        };

        let wanted = std::env::var("MONOLITH_VK_DEVICE").ok();

        let picked = unsafe { pick_physical(&instance, wanted.as_deref()) };

        let Some((physical, queue_family, name)) = picked else {

            unsafe { instance.destroy_instance(None) };

            return Err(Error::NoSuitableDevice);

        };

        let priorities = [1.0];

        let queues = [vk::DeviceQueueCreateInfo::default()

            .queue_family_index(queue_family)

            .queue_priorities(&priorities)];

        let extensions = [ash::khr::push_descriptor::NAME.as_ptr()];

        let mut features13 = vk::PhysicalDeviceVulkan13Features::default()

            .dynamic_rendering(true)

            .synchronization2(true);

        let info = vk::DeviceCreateInfo::default()

            .queue_create_infos(&queues)

            .enabled_extension_names(&extensions)

            .push_next(&mut features13);

        let device = match unsafe { instance.create_device(physical, &info, None) } {

            Ok(d) => d,

            Err(e) => {

                unsafe { instance.destroy_instance(None) };

                return Err(e.into());

            }

        };

        let queue = unsafe { device.get_device_queue(queue_family, 0) };

        let push_descriptor = ash::khr::push_descriptor::Device::new(&instance, &device);

        let allocator = Allocator::new(&AllocatorCreateDesc {

            instance: instance.clone(),

            device: device.clone(),

            physical_device: physical,

            debug_settings: Default::default(),

            buffer_device_address: false,

            allocation_sizes: Default::default(),

        });

        let device = Device {

            _entry: entry,

            instance,

            physical,

            device,

            queue: Mutex::new(queue),

            queue_family,

            push_descriptor,

            name,

        };

        Ok(Self {

            allocator: Mutex::new(allocator?),

            device,

        })

    }

}

unsafe fn pick_physical(

    instance: &ash::Instance,

    wanted: Option<&str>,

) -> Option<(vk::PhysicalDevice, u32, String)> {

    let devices = unsafe { instance.enumerate_physical_devices() }.ok()?;

    let mut candidates = Vec::new();

    for physical in devices {

        let props = unsafe { instance.get_physical_device_properties(physical) };

        if props.api_version < vk::API_VERSION_1_3 {

            continue;

        }

        let name = props

            .device_name_as_c_str()

            .unwrap_or(c"unknown")

            .to_string_lossy()

            .into_owned();

        if wanted.is_some_and(|w| !name.contains(w)) {

            continue;

        }

        let mut f13 = vk::PhysicalDeviceVulkan13Features::default();

        let mut f2 = vk::PhysicalDeviceFeatures2::default().push_next(&mut f13);

        unsafe { instance.get_physical_device_features2(physical, &mut f2) };

        if f13.dynamic_rendering == vk::FALSE || f13.synchronization2 == vk::FALSE {

            continue;

        }

        let has_push = unsafe { instance.enumerate_device_extension_properties(physical) }

            .unwrap_or_default()

            .iter()

            .any(|e| e.extension_name_as_c_str().ok() == Some(ash::khr::push_descriptor::NAME));

        if !has_push {

            continue;

        }

        let families = unsafe { instance.get_physical_device_queue_family_properties(physical) };

        let Some(family) = families

            .iter()

            .position(|f| f.queue_flags.contains(vk::QueueFlags::GRAPHICS))

        else {

            continue;

        };

        let rank = match props.device_type {

            vk::PhysicalDeviceType::DISCRETE_GPU => 0,

            vk::PhysicalDeviceType::INTEGRATED_GPU => 1,

            vk::PhysicalDeviceType::VIRTUAL_GPU => 2,

            _ => 3,

        };

        candidates.push((rank, physical, family as u32, name));

    }

    candidates.sort_by_key(|c| c.0);

    candidates.into_iter().next().map(|(_, p, f, n)| (p, f, n))

}