use std::sync::Arc;

use ash::vk;
use renderer_device::{
    device::{MemoryLocation, QueueFlags},
    testing::TestVulkan,
};
use renderer_resources::{
    buffers::{Buffer, BufferDesc},
    pipeline::{
        BufferDescriptor, DescriptorPool, DescriptorPoolDesc, DescriptorSetAllocDesc,
        DescriptorSetLayout, DescriptorSetLayoutBindingDesc, DescriptorSetLayoutDesc,
    },
};

#[test]
fn managed_set_write_and_pool_reset_under_validation() {
    let Some(test) = TestVulkan::acquire() else {
        return;
    };
    let device = test.device().clone();
    let buffer = Arc::new(
        Buffer::new(
            device.clone(),
            BufferDesc {
                size: 256,
                usage: vk::BufferUsageFlags::UNIFORM_BUFFER,
                queue_families: QueueFlags::empty(),
                mem_location: MemoryLocation::CpuToGpu,
                ..Default::default()
            },
        )
        .expect("create descriptor buffer"),
    );
    let bindings = [DescriptorSetLayoutBindingDesc {
        binding: 0,
        count: 1,
        kind: vk::DescriptorType::UNIFORM_BUFFER,
        stage: vk::ShaderStageFlags::VERTEX,
        flags: None,
    }];
    let layout = DescriptorSetLayout::new(
        device.clone(),
        DescriptorSetLayoutDesc {
            bindings: &bindings,
            ..Default::default()
        },
    )
    .expect("create descriptor set layout");
    let sizes = [vk::DescriptorPoolSize::default()
        .ty(vk::DescriptorType::UNIFORM_BUFFER)
        .descriptor_count(1)];
    let pool = DescriptorPool::new(
        device,
        DescriptorPoolDesc {
            sizes: &sizes,
            max_sets: 1,
            ..Default::default()
        },
    )
    .expect("create descriptor pool");
    let mut set = pool
        .allocate_managed(DescriptorSetAllocDesc {
            name: None,
            layout: &layout,
        })
        .expect("allocate managed descriptor set");
    let mut writer = set.writer().expect("create descriptor writer");
    writer
        .write_buffer(
            0,
            0,
            &[BufferDescriptor {
                buffer: &buffer,
                offset: 0,
                range: 256,
            }],
        )
        .expect("stage buffer descriptor");
    writer.commit().expect("commit buffer descriptor");

    test.device().wait_idle().expect("wait for device idle");
    drop(set);
    // SAFETY: no command uses this set, the device is idle, and this test excludes concurrent use.
    unsafe { pool.reset() }.expect("reset descriptor pool");
    drop(pool);
    drop(layout);
    drop(buffer);
    test.assert_no_validation_errors();
}