mod all_dxgi {
    pub use winapi::shared::{
        dxgi::*, dxgi1_2::*, dxgi1_3::*, dxgi1_4::*, dxgi1_6::*, dxgiformat::*, dxgitype::*,
    };
}
use gpu_allocator::d3d12::ToWinapi;
use winapi::um::d3d12::*;
use winapi::um::d3dcommon::*;
use winapi::Interface;

use winapi::shared::winerror::FAILED;

use gpu_allocator::d3d12::{Allocation, AllocationCreateDesc, Allocator};
use gpu_allocator::MemoryLocation;

use super::transition_resource;

#[repr(C)]
#[derive(Clone, Copy)]
struct ImGuiCBuffer {
    scale: [f32; 2],
    translation: [f32; 2],
}

pub struct ImGuiRenderer {
    root_signature: *mut ID3D12RootSignature,
    pipeline: *mut ID3D12PipelineState,

    vb_capacity: u64,
    ib_capacity: u64,
    vb_allocation: Allocation,
    ib_allocation: Allocation,
    vb_pointer: *mut u8,
    ib_pointer: *mut u8,
    vertex_buffer: *mut ID3D12Resource,
    index_buffer: *mut ID3D12Resource,

    cb_allocation: Allocation,
    cb_pointer: *mut u8,
    constant_buffer: *mut ID3D12Resource,

    font_image: *mut ID3D12Resource,
    font_image_memory: Allocation,
    font_image_srv_index: usize,

    font_image_upload_buffer: *mut ID3D12Resource,
    font_image_upload_buffer_memory: Allocation,
}

impl ImGuiRenderer {
    pub(crate) fn new(
        imgui: &mut imgui::Context,
        device: &mut ID3D12Device,
        allocator: &mut Allocator,
        descriptor_heap: &mut ID3D12DescriptorHeap,
        descriptor_heap_counter: &mut usize,
        cmd: &mut ID3D12GraphicsCommandList,
    ) -> Self {
        let root_signature = {
            let mut root_parameters = [
                D3D12_ROOT_PARAMETER {
                    ParameterType: D3D12_ROOT_PARAMETER_TYPE_CBV,
                    ShaderVisibility: D3D12_SHADER_VISIBILITY_ALL,
                    ..Default::default()
                },
                D3D12_ROOT_PARAMETER {
                    ParameterType: D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE,
                    ShaderVisibility: D3D12_SHADER_VISIBILITY_ALL,
                    ..Default::default()
                },
            ];

            let ranges = [D3D12_DESCRIPTOR_RANGE {
                RangeType: D3D12_DESCRIPTOR_RANGE_TYPE_SRV,
                NumDescriptors: 1,
                BaseShaderRegister: 2,
                RegisterSpace: 0,
                OffsetInDescriptorsFromTableStart: 0,
            }];
            unsafe {
                root_parameters[0].u.Descriptor_mut().ShaderRegister = 0;
                root_parameters[0].u.Descriptor_mut().RegisterSpace = 0;
                root_parameters[1]
                    .u
                    .DescriptorTable_mut()
                    .NumDescriptorRanges = ranges.len() as u32;
                root_parameters[1].u.DescriptorTable_mut().pDescriptorRanges = ranges.as_ptr();
            }

            let static_samplers = [D3D12_STATIC_SAMPLER_DESC {
                Filter: D3D12_FILTER_MIN_MAG_MIP_LINEAR,
                AddressU: D3D12_TEXTURE_ADDRESS_MODE_CLAMP,
                AddressV: D3D12_TEXTURE_ADDRESS_MODE_CLAMP,
                AddressW: D3D12_TEXTURE_ADDRESS_MODE_CLAMP,
                MipLODBias: 0.0,
                MaxAnisotropy: 0,
                ComparisonFunc: D3D12_COMPARISON_FUNC_ALWAYS,
                BorderColor: D3D12_STATIC_BORDER_COLOR_OPAQUE_BLACK,
                MinLOD: 0.0,
                MaxLOD: 0.0,
                ShaderRegister: 1,
                RegisterSpace: 0,
                ShaderVisibility: D3D12_SHADER_VISIBILITY_ALL,
            }];

            let rsig_desc = D3D12_ROOT_SIGNATURE_DESC {
                NumParameters: root_parameters.len() as u32,
                pParameters: root_parameters.as_ptr(),
                NumStaticSamplers: static_samplers.len() as u32,
                pStaticSamplers: static_samplers.as_ptr(),
                Flags: D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT,
            };

            let mut blob = std::ptr::null_mut();
            let mut error_blob = std::ptr::null_mut();
            let hr = unsafe {
                D3D12SerializeRootSignature(
                    &rsig_desc,
                    D3D_ROOT_SIGNATURE_VERSION_1,
                    &mut blob,
                    &mut error_blob,
                )
            };
            if FAILED(hr) {
                let error = unsafe {
                    let error_blob = error_blob.as_ref().unwrap();
                    std::slice::from_raw_parts(
                        error_blob.GetBufferPointer() as *const u8,
                        error_blob.GetBufferSize(),
                    )
                };

                panic!(
                    "Failed to serialize root signature: '{}'. hr: {:#x}",
                    std::str::from_utf8(error).unwrap(),
                    hr
                );
            }

            let blob = unsafe { blob.as_ref() }.unwrap();
            let mut rsig = std::ptr::null_mut();
            let hr = unsafe {
                device.CreateRootSignature(
                    0,
                    blob.GetBufferPointer(),
                    blob.GetBufferSize(),
                    &ID3D12RootSignature::uuidof(),
                    <*mut *mut ID3D12RootSignature>::cast(&mut rsig),
                )
            };
            if FAILED(hr) {
                panic!("Failed to create root signature. hr: {:#x}", hr);
            }

            unsafe { rsig.as_mut() }.unwrap()
        };

        let pipeline = unsafe {
            let vs = include_bytes!("./dxil/imgui.vs.dxil");
            let ps = include_bytes!("./dxil/imgui.ps.dxil");

            let input_elements = [
                D3D12_INPUT_ELEMENT_DESC {
                    SemanticName: b"POSITION\0".as_ptr().cast(),
                    SemanticIndex: 0,
                    Format: all_dxgi::DXGI_FORMAT_R32G32_FLOAT,
                    InputSlot: 0,
                    AlignedByteOffset: 0,
                    InputSlotClass: D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA,
                    InstanceDataStepRate: 0,
                },
                D3D12_INPUT_ELEMENT_DESC {
                    SemanticName: b"TEXCOORD\0".as_ptr().cast(),
                    SemanticIndex: 0,
                    Format: all_dxgi::DXGI_FORMAT_R32G32_FLOAT,
                    InputSlot: 0,
                    AlignedByteOffset: 8,
                    InputSlotClass: D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA,
                    InstanceDataStepRate: 0,
                },
                D3D12_INPUT_ELEMENT_DESC {
                    SemanticName: b"COLOR\0".as_ptr().cast(),
                    SemanticIndex: 0,
                    Format: all_dxgi::DXGI_FORMAT_R8G8B8A8_UNORM,
                    InputSlot: 0,
                    AlignedByteOffset: 16,
                    InputSlotClass: D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA,
                    InstanceDataStepRate: 0,
                },
            ];

            let desc = D3D12_GRAPHICS_PIPELINE_STATE_DESC {
                pRootSignature: root_signature,
                VS: D3D12_SHADER_BYTECODE {
                    pShaderBytecode: vs.as_ptr().cast(),
                    BytecodeLength: vs.len(),
                },
                PS: D3D12_SHADER_BYTECODE {
                    pShaderBytecode: ps.as_ptr().cast(),
                    BytecodeLength: ps.len(),
                },
                BlendState: D3D12_BLEND_DESC {
                    AlphaToCoverageEnable: 0,
                    IndependentBlendEnable: 0,
                    RenderTarget: [
                        D3D12_RENDER_TARGET_BLEND_DESC {
                            BlendEnable: 1,
                            LogicOpEnable: 0,
                            SrcBlend: D3D12_BLEND_SRC_ALPHA,
                            DestBlend: D3D12_BLEND_INV_SRC_ALPHA,
                            BlendOp: D3D12_BLEND_OP_ADD,
                            SrcBlendAlpha: D3D12_BLEND_ONE,
                            DestBlendAlpha: D3D12_BLEND_ZERO,
                            BlendOpAlpha: D3D12_BLEND_OP_ADD,
                            LogicOp: D3D12_LOGIC_OP_NOOP,
                            RenderTargetWriteMask: D3D12_COLOR_WRITE_ENABLE_ALL as u8,
                        },
                        D3D12_RENDER_TARGET_BLEND_DESC::default(),
                        D3D12_RENDER_TARGET_BLEND_DESC::default(),
                        D3D12_RENDER_TARGET_BLEND_DESC::default(),
                        D3D12_RENDER_TARGET_BLEND_DESC::default(),
                        D3D12_RENDER_TARGET_BLEND_DESC::default(),
                        D3D12_RENDER_TARGET_BLEND_DESC::default(),
                        D3D12_RENDER_TARGET_BLEND_DESC::default(),
                    ],
                },
                SampleMask: !0u32,
                RasterizerState: D3D12_RASTERIZER_DESC {
                    FillMode: D3D12_FILL_MODE_SOLID,
                    CullMode: D3D12_CULL_MODE_NONE,
                    FrontCounterClockwise: 0,
                    DepthBias: 0,
                    DepthBiasClamp: 0.0,
                    SlopeScaledDepthBias: 0.0,
                    DepthClipEnable: 0,
                    MultisampleEnable: 0,
                    AntialiasedLineEnable: 0,
                    ForcedSampleCount: 1,
                    ConservativeRaster: D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF,
                },
                DepthStencilState: D3D12_DEPTH_STENCIL_DESC {
                    DepthEnable: 0,
                    DepthWriteMask: D3D12_DEPTH_WRITE_MASK_ZERO,
                    DepthFunc: D3D12_COMPARISON_FUNC_ALWAYS,
                    StencilEnable: 0,
                    StencilReadMask: 0,
                    StencilWriteMask: 0,
                    FrontFace: D3D12_DEPTH_STENCILOP_DESC::default(),
                    BackFace: D3D12_DEPTH_STENCILOP_DESC::default(),
                },
                InputLayout: D3D12_INPUT_LAYOUT_DESC {
                    pInputElementDescs: input_elements.as_ptr(),
                    NumElements: input_elements.len() as u32,
                },
                PrimitiveTopologyType: D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE,
                NumRenderTargets: 1,
                RTVFormats: [
                    all_dxgi::DXGI_FORMAT_R8G8B8A8_UNORM,
                    all_dxgi::DXGI_FORMAT_UNKNOWN,
                    all_dxgi::DXGI_FORMAT_UNKNOWN,
                    all_dxgi::DXGI_FORMAT_UNKNOWN,
                    all_dxgi::DXGI_FORMAT_UNKNOWN,
                    all_dxgi::DXGI_FORMAT_UNKNOWN,
                    all_dxgi::DXGI_FORMAT_UNKNOWN,
                    all_dxgi::DXGI_FORMAT_UNKNOWN,
                ],
                SampleDesc: all_dxgi::DXGI_SAMPLE_DESC {
                    Quality: 0,
                    Count: 1,
                },

                ..Default::default()
            };

            let mut pipeline: *mut ID3D12PipelineState = std::ptr::null_mut();
            let hr = device.CreateGraphicsPipelineState(
                &desc,
                &ID3D12PipelineState::uuidof(),
                <*mut *mut ID3D12PipelineState>::cast(&mut pipeline),
            );
            if FAILED(hr) {
                panic!("Failed to create imgui pipeline: {:#x}", hr);
            }

            pipeline.as_mut().unwrap()
        };

        let (
            font_image,
            font_image_memory,
            font_image_srv_index,
            font_image_upload_buffer,
            font_image_upload_buffer_memory,
        ) = {
            let fonts = imgui.fonts();
            let font_atlas = fonts.build_rgba32_texture();

            let desc = D3D12_RESOURCE_DESC {
                Dimension: D3D12_RESOURCE_DIMENSION_TEXTURE2D,
                Alignment: 0,
                Width: font_atlas.width as u64,
                Height: font_atlas.height,
                DepthOrArraySize: 1,
                MipLevels: 1,
                Format: all_dxgi::DXGI_FORMAT_R8G8B8A8_UNORM,
                SampleDesc: all_dxgi::DXGI_SAMPLE_DESC {
                    Count: 1,
                    Quality: 0,
                },
                Layout: D3D12_TEXTURE_LAYOUT_UNKNOWN,
                Flags: D3D12_RESOURCE_FLAG_NONE,
            };
            let font_image_memory = allocator
                .allocate(&AllocationCreateDesc::from_winapi_d3d12_resource_desc(
                    device,
                    &desc,
                    "font_image",
                    MemoryLocation::GpuOnly,
                ))
                .unwrap();

            let font_image = unsafe {
                let mut font_image: *mut ID3D12Resource = std::ptr::null_mut();
                let hr = device.CreatePlacedResource(
                    font_image_memory.heap().as_winapi() as *mut _,
                    font_image_memory.offset(),
                    &desc,
                    D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE,
                    std::ptr::null(),
                    &ID3D12Resource::uuidof(),
                    <*mut *mut ID3D12Resource>::cast(&mut font_image),
                );
                if FAILED(hr) {
                    panic!("Failed to create font image. hr: {:#x}", hr);
                }

                font_image
            };

            //Create SRV
            let srv_index = unsafe {
                let srv_index = *descriptor_heap_counter;
                *descriptor_heap_counter += 1;

                let srv_size = device
                    .GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV)
                    as usize;

                let desc_heap_handle = descriptor_heap.GetCPUDescriptorHandleForHeapStart();
                let desc_heap_handle = D3D12_CPU_DESCRIPTOR_HANDLE {
                    ptr: desc_heap_handle.ptr + srv_index * srv_size,
                };

                const fn d3d12_encode_shader_4_component_mapping(
                    src0: u32,
                    src1: u32,
                    src2: u32,
                    src3: u32,
                ) -> u32 {
                    (src0 & D3D12_SHADER_COMPONENT_MAPPING_MASK)
                        | ((src1 & D3D12_SHADER_COMPONENT_MAPPING_MASK)
                            << (D3D12_SHADER_COMPONENT_MAPPING_SHIFT))
                        | ((src2 & D3D12_SHADER_COMPONENT_MAPPING_MASK)
                            << (D3D12_SHADER_COMPONENT_MAPPING_SHIFT * 2))
                        | ((src3 & D3D12_SHADER_COMPONENT_MAPPING_MASK)
                            << (D3D12_SHADER_COMPONENT_MAPPING_SHIFT * 3))
                        | D3D12_SHADER_COMPONENT_MAPPING_ALWAYS_SET_BIT_AVOIDING_ZEROMEM_MISTAKES
                }
                const fn d3d12_default_shader_4_component_mapping() -> u32 {
                    d3d12_encode_shader_4_component_mapping(0, 1, 2, 3)
                }

                let mut srv_desc = D3D12_SHADER_RESOURCE_VIEW_DESC {
                    Format: all_dxgi::DXGI_FORMAT_R8G8B8A8_UNORM,
                    ViewDimension: D3D12_SRV_DIMENSION_TEXTURE2D,
                    Shader4ComponentMapping: d3d12_default_shader_4_component_mapping(),
                    ..Default::default()
                };
                srv_desc.u.Texture2D_mut().MostDetailedMip = 0;
                srv_desc.u.Texture2D_mut().MipLevels = 1;
                srv_desc.u.Texture2D_mut().PlaneSlice = 0;
                srv_desc.u.Texture2D_mut().ResourceMinLODClamp = 0.0;
                device.CreateShaderResourceView(font_image, &srv_desc, desc_heap_handle);
                srv_index
            };

            let mut layouts = [D3D12_PLACED_SUBRESOURCE_FOOTPRINT::default()];
            let mut num_rows: u32 = 0;
            let mut row_size_in_bytes: u64 = 0;
            let mut total_bytes: u64 = 0;
            unsafe {
                device.GetCopyableFootprints(
                    &font_image.as_ref().unwrap().GetDesc(),
                    0,                    // first sub
                    layouts.len() as u32, // num sub
                    0,                    // intermediate offset
                    layouts.as_mut_ptr(),
                    &mut num_rows,
                    &mut row_size_in_bytes,
                    &mut total_bytes,
                )
            };

            // Create upload buffer
            let (upload_buffer, upload_buffer_memory) = {
                let desc = D3D12_RESOURCE_DESC {
                    Dimension: D3D12_RESOURCE_DIMENSION_BUFFER,
                    Alignment: 0,
                    Width: total_bytes,
                    Height: 1,
                    DepthOrArraySize: 1,
                    MipLevels: 1,
                    Format: all_dxgi::DXGI_FORMAT_UNKNOWN,
                    SampleDesc: all_dxgi::DXGI_SAMPLE_DESC {
                        Count: 1,
                        Quality: 0,
                    },
                    Layout: D3D12_TEXTURE_LAYOUT_ROW_MAJOR,
                    Flags: D3D12_RESOURCE_FLAG_NONE,
                };

                let upload_buffer_memory = allocator
                    .allocate(&AllocationCreateDesc::from_winapi_d3d12_resource_desc(
                        device,
                        &desc,
                        "font_image upload buffer",
                        MemoryLocation::CpuToGpu,
                    ))
                    .unwrap();

                let mut upload_buffer: *mut ID3D12Resource = std::ptr::null_mut();
                let hr = unsafe {
                    device.CreatePlacedResource(
                        upload_buffer_memory.heap().as_winapi() as *mut _,
                        upload_buffer_memory.offset(),
                        &desc,
                        D3D12_RESOURCE_STATE_GENERIC_READ,
                        std::ptr::null(),
                        &ID3D12Resource::uuidof(),
                        <*mut *mut ID3D12Resource>::cast(&mut upload_buffer),
                    )
                };

                if FAILED(hr) {
                    panic!("Failed to create font image upload buffer. hr: {:x}.", hr);
                }

                (upload_buffer, upload_buffer_memory)
            };

            unsafe {
                let mut mapped_ptr = std::ptr::null_mut();
                upload_buffer
                    .as_ref()
                    .unwrap()
                    .Map(0, std::ptr::null(), &mut mapped_ptr);
                let mapped_ptr = mapped_ptr.cast::<u8>();

                let layout = &layouts[0];
                let mapped_ptr = mapped_ptr.add(layout.Offset as usize);
                let source_ptr = font_atlas.data.as_ptr();

                for y in 0..layout.Footprint.Height {
                    let mapped_ptr = mapped_ptr.add((y * layout.Footprint.RowPitch) as usize);
                    let source_ptr = source_ptr.add((y * font_atlas.width * 4) as usize);

                    std::ptr::copy_nonoverlapping(
                        source_ptr,
                        mapped_ptr,
                        (layout.Footprint.Width * 4) as usize,
                    );
                }

                upload_buffer.as_ref().unwrap().Unmap(0, std::ptr::null())
            };

            let mut dst = D3D12_TEXTURE_COPY_LOCATION {
                pResource: font_image,
                Type: D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX,
                ..Default::default()
            };
            unsafe { *dst.u.SubresourceIndex_mut() = 0 };

            let mut src = D3D12_TEXTURE_COPY_LOCATION {
                pResource: upload_buffer,
                Type: D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT,
                ..Default::default()
            };
            unsafe { *src.u.PlacedFootprint_mut() = layouts[0] };

            unsafe {
                let barriers = [transition_resource(
                    font_image,
                    D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE,
                    D3D12_RESOURCE_STATE_COPY_DEST,
                )];
                cmd.ResourceBarrier(barriers.len() as u32, barriers.as_ptr());
                cmd.CopyTextureRegion(&dst, 0, 0, 0, &src, std::ptr::null())
            };

            (
                font_image,
                font_image_memory,
                srv_index,
                upload_buffer,
                upload_buffer_memory,
            )
        };

        let (constant_buffer, cb_allocation, cb_pointer) = {
            let desc = D3D12_RESOURCE_DESC {
                Dimension: D3D12_RESOURCE_DIMENSION_BUFFER,
                Alignment: 0,
                Width: std::mem::size_of::<ImGuiCBuffer>() as u64,
                Height: 1,
                DepthOrArraySize: 1,
                MipLevels: 1,
                Format: all_dxgi::DXGI_FORMAT_UNKNOWN,
                SampleDesc: all_dxgi::DXGI_SAMPLE_DESC {
                    Count: 1,
                    Quality: 0,
                },
                Layout: D3D12_TEXTURE_LAYOUT_ROW_MAJOR,
                Flags: D3D12_RESOURCE_FLAG_NONE,
            };

            let allocation = allocator
                .allocate(&AllocationCreateDesc::from_winapi_d3d12_resource_desc(
                    device,
                    &desc,
                    "ImGui Constant buffer",
                    MemoryLocation::CpuToGpu,
                ))
                .unwrap();

            let mut buffer: *mut ID3D12Resource = std::ptr::null_mut();
            let hr = unsafe {
                device.CreatePlacedResource(
                    allocation.heap().as_winapi() as *mut _,
                    allocation.offset(),
                    &desc,
                    D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER,
                    std::ptr::null(),
                    &ID3D12Resource::uuidof(),
                    <*mut *mut ID3D12Resource>::cast(&mut buffer),
                )
            };
            if FAILED(hr) {
                panic!("Failed to create constant buffer. hr: {:x}.", hr);
            }

            let mut mapped_ptr: *mut u8 = std::ptr::null_mut();
            unsafe {
                buffer.as_ref().unwrap().Map(
                    0,
                    std::ptr::null(),
                    <*mut *mut u8>::cast(&mut mapped_ptr),
                )
            };

            (buffer, allocation, mapped_ptr)
        };

        let vb_capacity = 1024 * 1024;
        let (vertex_buffer, vb_allocation, vb_pointer) = {
            let desc = D3D12_RESOURCE_DESC {
                Dimension: D3D12_RESOURCE_DIMENSION_BUFFER,
                Alignment: 0,
                Width: vb_capacity,
                Height: 1,
                DepthOrArraySize: 1,
                MipLevels: 1,
                Format: all_dxgi::DXGI_FORMAT_UNKNOWN,
                SampleDesc: all_dxgi::DXGI_SAMPLE_DESC {
                    Count: 1,
                    Quality: 0,
                },
                Layout: D3D12_TEXTURE_LAYOUT_ROW_MAJOR,
                Flags: D3D12_RESOURCE_FLAG_NONE,
            };

            let allocation = allocator
                .allocate(&AllocationCreateDesc::from_winapi_d3d12_resource_desc(
                    device,
                    &desc,
                    "ImGui Vertex buffer",
                    MemoryLocation::CpuToGpu,
                ))
                .unwrap();

            let mut buffer: *mut ID3D12Resource = std::ptr::null_mut();
            let hr = unsafe {
                device.CreatePlacedResource(
                    allocation.heap().as_winapi() as *mut _,
                    allocation.offset(),
                    &desc,
                    D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER,
                    std::ptr::null(),
                    &ID3D12Resource::uuidof(),
                    <*mut *mut ID3D12Resource>::cast(&mut buffer),
                )
            };
            if FAILED(hr) {
                panic!("Failed to create vertex buffer. hr: {:x}.", hr);
            }

            let mut mapped_ptr: *mut u8 = std::ptr::null_mut();
            unsafe {
                buffer.as_ref().unwrap().Map(
                    0,
                    std::ptr::null(),
                    <*mut *mut u8>::cast(&mut mapped_ptr),
                )
            };
            (buffer, allocation, mapped_ptr)
        };

        let ib_capacity = 1024 * 1024;
        let (index_buffer, ib_allocation, ib_pointer) = {
            let desc = D3D12_RESOURCE_DESC {
                Dimension: D3D12_RESOURCE_DIMENSION_BUFFER,
                Alignment: 0,
                Width: ib_capacity,
                Height: 1,
                DepthOrArraySize: 1,
                MipLevels: 1,
                Format: all_dxgi::DXGI_FORMAT_UNKNOWN,
                SampleDesc: all_dxgi::DXGI_SAMPLE_DESC {
                    Count: 1,
                    Quality: 0,
                },
                Layout: D3D12_TEXTURE_LAYOUT_ROW_MAJOR,
                Flags: D3D12_RESOURCE_FLAG_NONE,
            };

            let allocation = allocator
                .allocate(&AllocationCreateDesc::from_winapi_d3d12_resource_desc(
                    device,
                    &desc,
                    "ImGui Vertex buffer",
                    MemoryLocation::CpuToGpu,
                ))
                .unwrap();

            let mut buffer: *mut ID3D12Resource = std::ptr::null_mut();
            let hr = unsafe {
                device.CreatePlacedResource(
                    allocation.heap().as_winapi() as *mut _,
                    allocation.offset(),
                    &desc,
                    D3D12_RESOURCE_STATE_INDEX_BUFFER,
                    std::ptr::null(),
                    &ID3D12Resource::uuidof(),
                    <*mut *mut ID3D12Resource>::cast(&mut buffer),
                )
            };
            if FAILED(hr) {
                panic!("Failed to create vertex buffer. hr: {:x}.", hr);
            }

            let mut mapped_ptr: *mut u8 = std::ptr::null_mut();
            unsafe {
                buffer.as_ref().unwrap().Map(
                    0,
                    std::ptr::null(),
                    <*mut *mut u8>::cast(&mut mapped_ptr),
                )
            };
            (buffer, allocation, mapped_ptr)
        };

        Self {
            root_signature,
            pipeline,

            vb_capacity,
            ib_capacity,
            vb_allocation,
            ib_allocation,
            vb_pointer,
            ib_pointer,
            vertex_buffer,
            index_buffer,

            cb_allocation,
            cb_pointer,
            constant_buffer,

            font_image,
            font_image_memory,
            font_image_srv_index,

            font_image_upload_buffer,
            font_image_upload_buffer_memory,
        }
    }

    pub(crate) fn render(
        &mut self,
        imgui_draw_data: &imgui::DrawData,
        device: &mut ID3D12Device,
        window_width: u32,
        window_height: u32,
        descriptor_heap: &mut ID3D12DescriptorHeap,
        cmd: &mut ID3D12GraphicsCommandList,
    ) {
        // Update constant buffer
        {
            let left = imgui_draw_data.display_pos[0];
            let right = imgui_draw_data.display_pos[0] + imgui_draw_data.display_size[0];
            let top = imgui_draw_data.display_pos[1] + imgui_draw_data.display_size[1];
            let bottom = imgui_draw_data.display_pos[1];

            let cbuffer_data = ImGuiCBuffer {
                scale: [(2.0 / (right - left)), (2.0 / (bottom - top))],
                translation: [
                    (right + left) / (left - right),
                    (top + bottom) / (top - bottom),
                ],
            };

            unsafe { std::ptr::copy_nonoverlapping(&cbuffer_data, self.cb_pointer.cast(), 1) };
        }

        let (vtx_count, idx_count) =
            imgui_draw_data
                .draw_lists()
                .fold((0, 0), |(vtx_count, idx_count), draw_list| {
                    (
                        vtx_count + draw_list.vtx_buffer().len(),
                        idx_count + draw_list.idx_buffer().len(),
                    )
                });

        let vtx_size = (vtx_count * std::mem::size_of::<imgui::DrawVert>()) as u64;
        if vtx_size > self.vb_capacity {
            // reallocate vertex buffer
            todo!();
        }
        let idx_size = (idx_count * std::mem::size_of::<imgui::DrawIdx>()) as u64;
        if idx_size > self.ib_capacity {
            // reallocate index buffer
            todo!();
        }

        let mut vb_offset = 0;
        let mut ib_offset = 0;

        unsafe {
            let viewports = [D3D12_VIEWPORT {
                TopLeftX: 0.0,
                TopLeftY: 0.0,
                Width: window_width as f32,
                Height: window_height as f32,
                MinDepth: 0.0,
                MaxDepth: 1.0,
            }];
            cmd.RSSetViewports(viewports.len() as u32, viewports.as_ptr());

            cmd.SetPipelineState(self.pipeline);
            cmd.SetGraphicsRootSignature(self.root_signature);
            cmd.IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);

            {
                let constant_buffer = self.constant_buffer.as_mut().unwrap();
                let addr = constant_buffer.GetGPUVirtualAddress();
                cmd.SetGraphicsRootConstantBufferView(0, addr);
            }

            {
                let srv_stride =
                    device.GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
                let heap_handle = descriptor_heap.GetGPUDescriptorHandleForHeapStart();
                let heap_handle = D3D12_GPU_DESCRIPTOR_HANDLE {
                    ptr: heap_handle.ptr + srv_stride as u64 * self.font_image_srv_index as u64,
                };
                cmd.SetGraphicsRootDescriptorTable(1, heap_handle);
            }
        }

        for draw_list in imgui_draw_data.draw_lists() {
            let vertices = draw_list.vtx_buffer();
            let indices = draw_list.idx_buffer();

            let vbv = {
                let vertex_buffer = unsafe { self.vertex_buffer.as_mut().unwrap() };
                let stride = std::mem::size_of::<imgui::DrawVert>();
                let address =
                    unsafe { vertex_buffer.GetGPUVirtualAddress() } + (vb_offset * stride) as u64;

                D3D12_VERTEX_BUFFER_VIEW {
                    BufferLocation: address,
                    SizeInBytes: (vertices.len() * stride) as u32,
                    StrideInBytes: stride as u32,
                }
            };
            let ibv = {
                let index_buffer = unsafe { self.index_buffer.as_mut().unwrap() };
                let stride = std::mem::size_of::<u16>();
                let address =
                    unsafe { index_buffer.GetGPUVirtualAddress() } + (ib_offset * stride) as u64;

                D3D12_INDEX_BUFFER_VIEW {
                    BufferLocation: address,
                    SizeInBytes: (indices.len() * stride) as u32,
                    Format: all_dxgi::DXGI_FORMAT_R16_UINT,
                }
            };

            // Upload vertices
            unsafe {
                let stride = std::mem::size_of::<imgui::DrawVert>();
                let dst_ptr = self
                    .vb_pointer
                    .add(vb_offset * stride)
                    .cast::<imgui::DrawVert>();
                std::ptr::copy_nonoverlapping(vertices.as_ptr(), dst_ptr, vertices.len());
            }
            vb_offset += vertices.len();

            // Upload indices
            unsafe {
                let stride = std::mem::size_of::<u16>();
                let dst_ptr = self.ib_pointer.add(ib_offset * stride).cast();
                std::ptr::copy_nonoverlapping(indices.as_ptr(), dst_ptr, indices.len());
            }
            ib_offset += indices.len();

            unsafe {
                cmd.IASetVertexBuffers(0, 1, &vbv);
                cmd.IASetIndexBuffer(&ibv);
            };
            for command in draw_list.commands() {
                match command {
                    imgui::DrawCmd::Elements { count, cmd_params } => {
                        let scissor_rect = D3D12_RECT {
                            left: cmd_params.clip_rect[0] as i32,
                            top: cmd_params.clip_rect[1] as i32,
                            right: cmd_params.clip_rect[2] as i32,
                            bottom: cmd_params.clip_rect[3] as i32,
                        };
                        unsafe {
                            cmd.RSSetScissorRects(1, &scissor_rect);
                            cmd.DrawIndexedInstanced(
                                count as u32,
                                1,
                                cmd_params.idx_offset as u32,
                                cmd_params.vtx_offset as i32,
                                0,
                            );
                        };
                    }
                    _ => todo!(),
                }
            }
        }
    }

    pub(crate) fn destroy(self, allocator: &mut Allocator) {
        unsafe { self.pipeline.as_ref().unwrap().Release() };

        unsafe { self.font_image_upload_buffer.as_ref().unwrap().Release() };
        unsafe { self.vertex_buffer.as_ref().unwrap().Release() };
        unsafe { self.index_buffer.as_ref().unwrap().Release() };
        unsafe { self.constant_buffer.as_ref().unwrap().Release() };
        unsafe { self.font_image.as_ref().unwrap().Release() };

        allocator
            .free(self.font_image_upload_buffer_memory)
            .unwrap();
        allocator.free(self.vb_allocation).unwrap();
        allocator.free(self.ib_allocation).unwrap();
        allocator.free(self.cb_allocation).unwrap();
        allocator.free(self.font_image_memory).unwrap();
    }
}

pub(crate) fn handle_imgui_event(
    io: &mut imgui::Io,
    window: &winit::window::Window,
    event: &winit::event::Event<'_, ()>,
) -> bool {
    use winit::event::{
        DeviceEvent, ElementState, Event, KeyboardInput, MouseButton, MouseScrollDelta, TouchPhase,
        VirtualKeyCode, WindowEvent,
    };

    match event {
        Event::WindowEvent { event, window_id } if *window_id == window.id() => match *event {
            WindowEvent::Resized(physical_size) => {
                io.display_size = [physical_size.width as f32, physical_size.height as f32];
                false
            }
            WindowEvent::KeyboardInput {
                input:
                    KeyboardInput {
                        virtual_keycode: Some(key),
                        state,
                        ..
                    },
                ..
            } => {
                let pressed = state == ElementState::Pressed;
                io.keys_down[key as usize] = pressed;
                match key {
                    VirtualKeyCode::LShift | VirtualKeyCode::RShift => io.key_shift = pressed,
                    VirtualKeyCode::LControl | VirtualKeyCode::RControl => io.key_ctrl = pressed,
                    VirtualKeyCode::LAlt | VirtualKeyCode::RAlt => io.key_alt = pressed,
                    VirtualKeyCode::LWin | VirtualKeyCode::RWin => io.key_super = pressed,
                    _ => (),
                }

                io.want_capture_keyboard
            }
            WindowEvent::ReceivedCharacter(ch) => {
                io.add_input_character(ch);

                io.want_capture_keyboard
            }

            WindowEvent::CursorMoved { position, .. } => {
                io.mouse_pos = [position.x as f32, position.y as f32];

                io.want_capture_mouse
            }
            WindowEvent::MouseWheel {
                delta,
                phase: TouchPhase::Moved,
                ..
            } => {
                match delta {
                    MouseScrollDelta::LineDelta(h, v) => {
                        io.mouse_wheel_h = h;
                        io.mouse_wheel = v;
                    }
                    MouseScrollDelta::PixelDelta(pos) => {
                        match pos.x.partial_cmp(&0.0) {
                            Some(std::cmp::Ordering::Greater) => io.mouse_wheel_h += 1.0,
                            Some(std::cmp::Ordering::Less) => io.mouse_wheel_h -= 1.0,
                            _ => (),
                        }
                        match pos.y.partial_cmp(&0.0) {
                            Some(std::cmp::Ordering::Greater) => io.mouse_wheel += 1.0,
                            Some(std::cmp::Ordering::Less) => io.mouse_wheel -= 1.0,
                            _ => (),
                        }
                    }
                }

                io.want_capture_mouse
            }
            WindowEvent::MouseInput { state, button, .. } => {
                let pressed = state == ElementState::Pressed;
                match button {
                    MouseButton::Left => io.mouse_down[0] = pressed,
                    MouseButton::Right => io.mouse_down[1] = pressed,
                    MouseButton::Middle => io.mouse_down[2] = pressed,
                    MouseButton::Other(idx @ 0..=4) => io.mouse_down[idx as usize] = pressed,
                    MouseButton::Other(_) => (),
                }

                io.want_capture_mouse
            }
            _ => false,
        },
        // Track key release events outside our window. If we don't do this,
        // we might never see the release event if some other window gets focus.
        Event::DeviceEvent {
            event:
                DeviceEvent::Key(KeyboardInput {
                    state: ElementState::Released,
                    virtual_keycode: Some(key),
                    ..
                }),
            ..
        } => {
            io.keys_down[*key as usize] = false;
            match *key {
                VirtualKeyCode::LShift | VirtualKeyCode::RShift => io.key_shift = false,
                VirtualKeyCode::LControl | VirtualKeyCode::RControl => io.key_ctrl = false,
                VirtualKeyCode::LAlt | VirtualKeyCode::RAlt => io.key_alt = false,
                VirtualKeyCode::LWin | VirtualKeyCode::RWin => io.key_super = false,
                _ => (),
            }

            io.want_capture_keyboard
        }
        _ => false,
    }
}