use alloc::{borrow::Cow, boxed::Box, sync::Arc, vec::Vec};
use core::ops::Deref;
use core::ptr::NonNull;
use wgpu_core_remote_types::{
    encoders::{RenderBundleDescriptor, RenderBundleEncoderDescriptor},
    pipelines::{ComputePipelineDescriptor, RenderPipelineDescriptor},
    BufferDescriptor, ExternalTextureDescriptor, PipelineLayoutDescriptor, QuerySetDescriptor,
    SamplerDescriptor, ShaderModuleDescriptor, TextureDescriptor, TextureViewDescriptor,
};

use wgpu_core::{
    binding_model::{self},
    command,
    device::{DeviceLostClosure, WaitIdleError},
    error::EmptyErrorScopeStack,
    pipeline::{
        self, ProgrammableStageDescriptor, RenderPipelineVertexProcessor,
        ResolvedGeneralRenderPipelineDescriptor,
    },
    resource::{self, BufferAccessError, BufferMapOperation, CreateBufferError},
    Label, LabelHelpers, SubmissionIndex,
};

use crate::{
    global::Global,
    hub::Hub,
    id::{self, DeviceId, QueueId},
    registry::Registry,
};

use wgt::{error::WebGpuError, BufferAddress};

pub use wgpu_core_remote_types::binding_model::*;

impl Global {
    pub fn device_features(&self, device_id: DeviceId) -> wgt::Features {
        let hub = self.hub.borrow();
        let device = hub.devices.get(device_id);
        *device.features()
    }

    pub fn device_limits(&self, device_id: DeviceId) -> wgt::Limits {
        let hub = self.hub.borrow();
        let device = hub.devices.get(device_id);
        device.limits().clone()
    }

    pub fn device_adapter_info(&self, device_id: DeviceId) -> wgt::AdapterInfo {
        let hub = self.hub.borrow();
        let device = hub.devices.get(device_id);
        device.adapter_info()
    }

    pub fn device_downlevel_properties(&self, device_id: DeviceId) -> wgt::DownlevelCapabilities {
        let hub = self.hub.borrow();
        let device = hub.devices.get(device_id);
        device.downlevel().clone()
    }

    pub fn device_create_buffer(
        &self,
        device_id: DeviceId,
        desc: &BufferDescriptor,
        id_in: id::BufferId,
    ) {
        let mut hub = self.hub.borrow_mut();
        let Hub {
            buffers, devices, ..
        } = &mut *hub;

        let device = devices.get(device_id);

        let buffer = device.create_buffer(desc);

        buffers.assign(id_in, buffer);
    }

    /// Assign `id_in` an error with the given `label`.
    ///
    /// Ensure that future attempts to use `id_in` as a buffer ID will propagate
    /// the error, following the WebGPU ["contagious invalidity"] style.
    ///
    /// Firefox uses this function to comply strictly with the WebGPU spec,
    /// which requires [`GPUBufferDescriptor`] validation to be generated on the
    /// Device timeline and leave the newly created [`GPUBuffer`] invalid.
    ///
    /// Ideally, we would simply let [`Device::create_buffer`] take care of all
    /// of this, but some errors must be detected before we can even construct a
    /// [`wgpu_types::BufferDescriptor`] to give it. For example, the WebGPU API
    /// allows a `GPUBufferDescriptor`'s [`usage`] property to be any WebIDL
    /// `unsigned long` value, but we can't construct a
    /// [`wgpu_types::BufferUsages`] value from values with unassigned bits
    /// set. This means we must validate `usage` before we can call
    /// `Device::create_buffer`.
    ///
    /// When that validation fails, we must arrange for the buffer id to be
    /// considered invalid. This method provides the means to do so.
    ///
    /// ["contagious invalidity"]: https://www.w3.org/TR/webgpu/#invalidity
    /// [`GPUBufferDescriptor`]: https://www.w3.org/TR/webgpu/#dictdef-gpubufferdescriptor
    /// [`GPUBuffer`]: https://www.w3.org/TR/webgpu/#gpubuffer
    /// [`wgpu_types::BufferDescriptor`]: wgt::BufferDescriptor
    /// [`Device::create_buffer`]: wgpu_core::device::Device::create_buffer
    /// [`usage`]: https://www.w3.org/TR/webgpu/#dom-gputexturedescriptor-usage
    /// [`wgpu_types::BufferUsages`]: wgt::BufferUsages
    pub fn create_buffer_error(
        &self,
        device_id: DeviceId,
        id_in: id::BufferId,
        desc: &BufferDescriptor,
    ) {
        let mut hub = self.hub.borrow_mut();
        let Hub {
            buffers, devices, ..
        } = &mut *hub;
        let device = devices.get(device_id);
        buffers.assign(id_in, resource::Buffer::invalid(device, desc));
    }

    /// Assign `id_in` an error with the given `label`.
    ///
    /// See [`Self::create_buffer_error`] for more context and explanation.
    pub fn create_render_bundle_error(
        &self,
        device_id: DeviceId,
        id_in: id::RenderBundleId,
        desc: &RenderBundleDescriptor,
    ) {
        let mut hub = self.hub.borrow_mut();
        let Hub {
            render_bundles,
            devices,
            ..
        } = &mut *hub;
        let device = devices.get(device_id);
        render_bundles.assign(id_in, command::RenderBundle::invalid(device, desc));
    }

    /// Assign `id_in` an error with the given `label`.
    ///
    /// See [`Self::create_buffer_error`] for more context and explanation.
    pub fn create_texture_error(
        &self,
        device_id: DeviceId,
        id_in: id::TextureId,
        desc: &TextureDescriptor,
    ) -> id::TextureId {
        let mut hub = self.hub.borrow_mut();
        let Hub {
            textures, devices, ..
        } = &mut *hub;
        let device = devices.get(device_id);
        let texture = device.create_texture_error(desc);
        textures.assign(id_in, texture)
    }

    /// Assign `id_in` an error with the given `label`.
    ///
    /// See [`Self::create_buffer_error`] for more context and explanation.
    pub fn create_external_texture_error(
        &self,
        device_id: DeviceId,
        id_in: id::ExternalTextureId,
        desc: &ExternalTextureDescriptor,
    ) {
        let mut hub = self.hub.borrow_mut();
        let Hub {
            external_textures,
            devices,
            ..
        } = &mut *hub;
        let device = devices.get(device_id);
        external_textures.assign(id_in, resource::ExternalTexture::invalid(device, desc));
    }

    /// Assign `id_in` an error with the given `label`.
    ///
    /// In JavaScript environments, it is possible to call `GPUDevice.createBindGroupLayout` with
    /// entries that are invalid. Because our Rust's types for bind group layouts prevent even
    /// calling [`Self::device_create_bind_group`], we let standards-compliant environments
    /// register an invalid bind group layout so this crate's API can still be consistently used.
    ///
    /// See [`Self::create_buffer_error`] for additional context and explanation.
    pub fn create_bind_group_layout_error(
        &self,
        device_id: DeviceId,
        id_in: id::BindGroupLayoutId,
        label: Option<Cow<'_, str>>,
    ) {
        let mut hub = self.hub.borrow_mut();
        let Hub {
            bind_group_layouts,
            devices,
            ..
        } = &mut *hub;
        let device = devices.get(device_id);
        bind_group_layouts.assign(
            id_in,
            binding_model::BindGroupLayout::invalid(&device, label.to_string()),
        );
    }

    pub fn buffer_destroy(&self, buffer_id: id::BufferId) {
        let hub = self.hub.borrow();

        let buffer = hub.buffers.get(buffer_id);

        buffer.destroy();
    }

    pub fn buffer_remove(&self, buffer_id: id::BufferId) -> Arc<resource::Buffer> {
        let mut hub = self.hub.borrow_mut();

        hub.buffers.remove(buffer_id)
    }

    pub fn device_create_texture(
        &self,
        device_id: DeviceId,
        desc: &TextureDescriptor,
        id_in: id::TextureId,
    ) {
        let mut hub = self.hub.borrow_mut();

        let Hub {
            textures, devices, ..
        } = &mut *hub;

        let device = devices.get(device_id);

        let texture = device.create_texture(desc);

        textures.assign(id_in, texture);
    }

    pub fn device_validate_texture_descriptor(
        &self,
        device_id: DeviceId,
        desc: &TextureDescriptor,
    ) -> Option<resource::CreateTextureError> {
        let hub = self.hub.borrow();
        hub.devices
            .get(device_id)
            .validate_texture_descriptor(desc)
            .err()
    }

    /// # Safety
    ///
    /// - `hal_texture` must be created from `device_id` corresponding raw handle.
    /// - `hal_texture` must be created respecting `desc`
    /// - `hal_texture` must be initialized
    /// - The `initial_state` must match the actual driver-side state of
    ///   the wrapped resource at the moment of wrap.
    pub unsafe fn create_texture_from_hal(
        &self,
        hal_texture: Box<dyn hal::DynTexture>,
        device_id: DeviceId,
        desc: &TextureDescriptor,
        initial_state: wgt::TextureUses,
        id_in: id::TextureId,
        cleared: bool,
    ) -> (id::TextureId, Option<resource::CreateTextureError>) {
        let mut hub = self.hub.borrow_mut();
        let Hub {
            textures, devices, ..
        } = &mut *hub;

        let device = devices.get(device_id);

        let (texture, error) =
            unsafe { device.create_texture_from_hal(hal_texture, desc, initial_state, cleared) };

        let id = textures.assign(id_in, texture);
        (id, error)
    }

    /// # Safety
    ///
    /// - `hal_buffer` must be created from `device_id` corresponding raw handle.
    /// - `hal_buffer` must be created respecting `desc`
    /// - `hal_buffer` must be initialized
    /// - `hal_buffer` must not have zero size.
    pub unsafe fn create_buffer_from_hal<A: hal::Api>(
        &self,
        hal_buffer: A::Buffer,
        device_id: DeviceId,
        desc: &BufferDescriptor,
        id_in: id::BufferId,
    ) -> (id::BufferId, Option<CreateBufferError>) {
        let mut hub = self.hub.borrow_mut();
        let Hub {
            buffers, devices, ..
        } = &mut *hub;

        let device = devices.get(device_id);

        let (buffer, err) = unsafe { device.create_buffer_from_hal(Box::new(hal_buffer), desc) };

        let id = buffers.assign(id_in, buffer);

        (id, err)
    }

    pub fn texture_destroy(&self, texture_id: id::TextureId) {
        let hub = self.hub.borrow();

        let texture = hub.textures.get(texture_id);

        texture.destroy();
    }

    pub fn texture_remove(&self, texture_id: id::TextureId) -> Arc<resource::Texture> {
        let mut hub = self.hub.borrow_mut();

        hub.textures.remove(texture_id)
    }

    /// # Safety
    ///
    /// The entire contents of the texture must already be initialized.
    pub unsafe fn texture_mark_externally_initialized(&self, texture_id: id::TextureId) {
        let hub = &self.hub.borrow();

        let texture = hub.textures.get(texture_id);

        unsafe { texture.mark_externally_initialized() };
    }

    pub fn texture_create_view(
        &self,
        texture_id: id::TextureId,
        desc: &TextureViewDescriptor,
        id_in: id::TextureViewId,
    ) {
        let mut hub = self.hub.borrow_mut();
        let Hub {
            textures,
            texture_views,
            ..
        } = &mut *hub;

        let texture = textures.get(texture_id);

        let desc = resource::TextureViewDescriptor {
            label: desc.label.as_ref().map(|s| Cow::Borrowed(s.deref())),
            format: desc.format,
            dimension: desc.dimension,
            usage: desc.usage,
            range: desc.range,
            swizzle: desc.swizzle,
        };

        let view = texture.create_view(&desc);

        texture_views.assign(id_in, view);
    }

    pub fn texture_view_remove(
        &self,
        texture_view_id: id::TextureViewId,
    ) -> Arc<resource::TextureView> {
        let mut hub = self.hub.borrow_mut();

        hub.texture_views.remove(texture_view_id)
    }

    pub fn device_create_external_texture(
        &self,
        device_id: DeviceId,
        desc: &ExternalTextureDescriptor,
        planes: &[id::TextureViewId],
        id_in: id::ExternalTextureId,
    ) {
        let mut hub = self.hub.borrow_mut();
        let Hub {
            external_textures,
            devices,
            texture_views,
            ..
        } = &mut *hub;

        let device = devices.get(device_id);

        let planes = planes
            .iter()
            .map(|plane_id| texture_views.get(*plane_id))
            .collect::<Vec<_>>();

        let external_texture = device.create_external_texture(desc, &planes);

        external_textures.assign(id_in, external_texture);
    }

    pub fn external_texture_destroy(&self, external_texture_id: id::ExternalTextureId) {
        let hub = self.hub.borrow();

        let external_texture = hub.external_textures.get(external_texture_id);

        external_texture.destroy();
    }

    pub fn external_texture_remove(
        &self,
        external_texture_id: id::ExternalTextureId,
    ) -> Arc<resource::ExternalTexture> {
        let mut hub = self.hub.borrow_mut();

        hub.external_textures.remove(external_texture_id)
    }

    pub fn device_create_sampler(
        &self,
        device_id: DeviceId,
        desc: &SamplerDescriptor,
        id_in: id::SamplerId,
    ) {
        let mut hub = self.hub.borrow_mut();
        let Hub {
            samplers, devices, ..
        } = &mut *hub;

        let device = devices.get(device_id);

        let desc = resource::SamplerDescriptor {
            label: desc.label.as_ref().map(|l| Cow::Borrowed(l.as_ref())),
            address_modes: desc.address_modes,
            mag_filter: desc.mag_filter,
            min_filter: desc.min_filter,
            mipmap_filter: desc.mipmap_filter,
            lod_min_clamp: desc.lod_min_clamp,
            lod_max_clamp: desc.lod_max_clamp,
            compare: desc.compare,
            anisotropy_clamp: desc.anisotropy_clamp,
            border_color: None,
        };

        let sampler = device.create_sampler(&desc);

        samplers.assign(id_in, sampler);
    }

    pub fn sampler_remove(&self, sampler_id: id::SamplerId) -> Arc<resource::Sampler> {
        let mut hub = self.hub.borrow_mut();

        hub.samplers.remove(sampler_id)
    }

    pub fn device_create_bind_group_layout(
        &self,
        device_id: DeviceId,
        desc: &BindGroupLayoutDescriptor,
        id_in: id::BindGroupLayoutId,
    ) {
        let mut hub = self.hub.borrow_mut();
        let Hub {
            bind_group_layouts,
            devices,
            ..
        } = &mut *hub;

        let device = devices.get(device_id);

        let desc = binding_model::BindGroupLayoutDescriptor {
            label: desc.label.as_ref().map(|l| Cow::Borrowed(l.as_ref())),
            entries: Cow::Borrowed(&desc.entries),
        };

        let bgl = device.create_bind_group_layout(&desc);

        bind_group_layouts.assign(id_in, bgl);
    }

    pub fn bind_group_layout_remove(
        &self,
        bind_group_layout_id: id::BindGroupLayoutId,
    ) -> Arc<binding_model::BindGroupLayout> {
        let mut hub = self.hub.borrow_mut();

        hub.bind_group_layouts.remove(bind_group_layout_id)
    }

    pub fn device_create_pipeline_layout(
        &self,
        device_id: DeviceId,
        desc: &PipelineLayoutDescriptor,
        id_in: id::PipelineLayoutId,
    ) {
        let mut hub = self.hub.borrow_mut();
        let Hub {
            pipeline_layouts,
            devices,
            bind_group_layouts,
            ..
        } = &mut *hub;

        let device = devices.get(device_id);

        let bind_group_layouts = desc
            .bind_group_layouts
            .iter()
            .map(|bgl_id| bgl_id.map(|bgl_id| bind_group_layouts.get(bgl_id)))
            .collect::<Vec<_>>();

        let desc = binding_model::PipelineLayoutDescriptor {
            label: desc.label.as_ref().map(|l| Cow::Borrowed(l.as_ref())),
            bind_group_layouts: Cow::Owned(bind_group_layouts),
            immediate_size: desc.immediate_size,
        };

        let layout = device.create_pipeline_layout(&desc);
        pipeline_layouts.assign(id_in, layout);
    }

    pub fn pipeline_layout_remove(
        &self,
        pipeline_layout_id: id::PipelineLayoutId,
    ) -> Arc<binding_model::PipelineLayout> {
        let mut hub = self.hub.borrow_mut();

        hub.pipeline_layouts.remove(pipeline_layout_id)
    }

    pub fn device_create_bind_group(
        &self,
        device_id: DeviceId,
        desc: &BindGroupDescriptor,
        id_in: id::BindGroupId,
    ) {
        let mut hub = self.hub.borrow_mut();
        let Hub {
            bind_groups,
            devices,
            bind_group_layouts,
            buffers,
            samplers,
            texture_views,
            external_textures,
            ..
        } = &mut *hub;

        let device = devices.get(device_id);

        let layout = bind_group_layouts.get(desc.layout);

        fn resolve_entry<'a>(
            e: &'a BindGroupEntry,
            buffers: &mut Registry<Arc<resource::Buffer>>,
            samplers: &mut Registry<Arc<resource::Sampler>>,
            texture_views: &mut Registry<Arc<resource::TextureView>>,
            external_textures: &mut Registry<Arc<resource::ExternalTexture>>,
        ) -> binding_model::BindGroupEntry<'a> {
            let resolve_buffer = |bb: &BufferBinding| {
                let buffer = buffers.get(bb.buffer);
                binding_model::BufferBinding {
                    buffer,
                    offset: bb.offset,
                    size: bb.size.to_std(),
                }
            };
            let resolve_sampler = |id: &id::SamplerId| samplers.get(*id);
            let resolve_view = |id: &id::TextureViewId| texture_views.get(*id);
            let resolve_external_texture = |id: &id::ExternalTextureId| external_textures.get(*id);
            let resource = match e.resource {
                BindingResource::Buffer(ref buffer) => {
                    binding_model::BindingResource::Buffer(resolve_buffer(buffer))
                }
                BindingResource::Sampler(ref sampler) => {
                    binding_model::BindingResource::Sampler(resolve_sampler(sampler))
                }
                BindingResource::TextureView(ref view) => {
                    binding_model::BindingResource::TextureView(resolve_view(view))
                }
                BindingResource::ExternalTexture(ref et) => {
                    binding_model::BindingResource::ExternalTexture(resolve_external_texture(et))
                }
            };
            binding_model::BindGroupEntry {
                binding: e.binding,
                resource,
            }
        }

        let entries = desc
            .entries
            .iter()
            .map(|e| resolve_entry(e, buffers, samplers, texture_views, external_textures))
            .collect::<Vec<_>>();
        let entries = Cow::Owned(entries);

        let desc = binding_model::BindGroupDescriptor {
            label: desc.label.clone(),
            layout,
            entries,
        };

        let bind_group = device.create_bind_group(&desc);

        bind_groups.assign(id_in, bind_group);
    }

    pub fn bind_group_remove(
        &self,
        bind_group_id: id::BindGroupId,
    ) -> Arc<binding_model::BindGroup> {
        let mut hub = self.hub.borrow_mut();

        hub.bind_groups.remove(bind_group_id)
    }

    /// Create a shader module with the given `source`.
    ///
    /// <div class="warning">
    // NOTE: Keep this in sync with `naga::front::wgsl::parse_str`!
    // NOTE: Keep this in sync with `wgpu::Device::create_shader_module`!
    ///
    /// This function may consume a lot of stack space. Compiler-enforced limits for parsing
    /// recursion exist; if shader compilation runs into them, it will return an error gracefully.
    /// However, on some build profiles and platforms, the default stack size for a thread may be
    /// exceeded before this limit is reached during parsing. Callers should ensure that there is
    /// enough stack space for this, particularly if calls to this method are exposed to user
    /// input.
    ///
    /// </div>
    pub fn device_create_shader_module(
        &self,
        device_id: DeviceId,
        desc: &ShaderModuleDescriptor,
        id_in: id::ShaderModuleId,
    ) {
        let mut hub = self.hub.borrow_mut();
        let Hub {
            shader_modules,
            devices,
            ..
        } = &mut *hub;

        let device = devices.get(device_id);

        let code = pipeline::ShaderModuleSource::Wgsl(Cow::Borrowed(&desc.code));

        let desc = pipeline::ShaderModuleDescriptor {
            label: desc.label.as_ref().map(|l| Cow::Borrowed(l.as_ref())),
            runtime_checks: wgt::ShaderRuntimeChecks::checked(),
        };

        let shader = device.create_shader_module(&desc, code);

        shader_modules.assign(id_in, shader);
    }

    pub fn shader_module_compilation_info(
        &self,
        shader_module_id: id::ShaderModuleId,
    ) -> wgt::CompilationInfo {
        let hub = self.hub.borrow();
        let shader_module = hub.shader_modules.get(shader_module_id);
        shader_module.compilation_info().clone()
    }

    pub fn shader_module_remove(
        &self,
        shader_module_id: id::ShaderModuleId,
    ) -> Arc<pipeline::ShaderModule> {
        let mut hub = self.hub.borrow_mut();

        hub.shader_modules.remove(shader_module_id)
    }

    pub fn device_create_command_encoder(
        &self,
        device_id: DeviceId,
        desc: &wgt::CommandEncoderDescriptor<Label>,
        id_in: id::CommandEncoderId,
    ) {
        let mut hub = self.hub.borrow_mut();
        let Hub {
            command_encoders,
            devices,
            ..
        } = &mut *hub;

        let device = devices.get(device_id);

        let cmd_enc = device.create_command_encoder(desc);

        command_encoders.assign(id_in, cmd_enc);
    }

    pub fn command_encoder_remove(
        &self,
        command_encoder_id: id::CommandEncoderId,
    ) -> Arc<command::CommandEncoder> {
        let mut hub = self.hub.borrow_mut();
        hub.command_encoders.remove(command_encoder_id)
    }

    pub fn command_buffer_remove(
        &self,
        command_buffer_id: id::CommandBufferId,
    ) -> Arc<command::CommandBuffer> {
        let mut hub = self.hub.borrow_mut();
        hub.command_buffers.remove(command_buffer_id)
    }

    pub fn device_create_render_bundle_encoder(
        &self,
        device_id: DeviceId,
        desc: &RenderBundleEncoderDescriptor,
        id_in: id::RenderBundleEncoderId,
    ) {
        let mut hub = self.hub.borrow_mut();
        let Hub {
            render_bundle_encoders,
            devices,
            ..
        } = &mut *hub;

        let device = devices.get(device_id);

        let desc = command::RenderBundleEncoderDescriptor {
            label: desc.label.as_ref().map(|l| Cow::Borrowed(l.as_ref())),
            color_formats: Cow::Borrowed(&desc.color_formats),
            depth_stencil: desc.depth_stencil,
            sample_count: desc.sample_count,
            multiview: None,
        };

        let render_bundle_encoder = device.create_render_bundle_encoder(&desc);

        render_bundle_encoders.assign(id_in, *render_bundle_encoder);
    }

    pub fn render_bundle_encoder_finish(
        &self,
        render_bundle_encoder_id: id::RenderBundleEncoderId,
        desc: RenderBundleDescriptor,
        id_in: id::RenderBundleId,
    ) {
        let mut hub = self.hub.borrow_mut();
        let Hub {
            render_bundle_encoders,
            render_bundles,
            ..
        } = &mut *hub;
        let bundle_encoder = render_bundle_encoders.get_mut(render_bundle_encoder_id);

        let RenderBundleDescriptor { label } = desc;
        let desc = wgt::RenderBundleDescriptor { label };

        let render_bundle = bundle_encoder.finish(&desc);

        render_bundles.assign(id_in, render_bundle);
    }

    pub fn render_bundle_encoder_remove(
        &self,
        render_bundle_encoder_id: id::RenderBundleEncoderId,
    ) -> command::RenderBundleEncoder {
        let mut hub = self.hub.borrow_mut();
        hub.render_bundle_encoders.remove(render_bundle_encoder_id)
    }

    pub fn render_bundle_remove(
        &self,
        render_bundle_id: id::RenderBundleId,
    ) -> Arc<command::RenderBundle> {
        let mut hub = self.hub.borrow_mut();
        hub.render_bundles.remove(render_bundle_id)
    }

    pub fn device_create_query_set(
        &self,
        device_id: DeviceId,
        desc: &QuerySetDescriptor,
        id_in: id::QuerySetId,
    ) {
        let mut hub = self.hub.borrow_mut();
        let Hub {
            query_sets,
            devices,
            ..
        } = &mut *hub;

        let device = devices.get(device_id);

        let query_set = device.create_query_set(desc);

        query_sets.assign(id_in, query_set);
    }

    pub fn query_set_destroy(&self, query_set_id: id::QuerySetId) {
        let hub = self.hub.borrow();

        let query_set = hub.query_sets.get(query_set_id);

        query_set.destroy();
    }

    pub fn query_set_remove(&self, query_set_id: id::QuerySetId) -> Arc<resource::QuerySet> {
        let mut hub = self.hub.borrow_mut();

        hub.query_sets.remove(query_set_id)
    }

    fn resolve_render_pipeline_descriptor<'a>(
        shader_modules: &mut Registry<Arc<pipeline::ShaderModule>>,
        pipeline_layouts: &mut Registry<Arc<binding_model::PipelineLayout>>,
        desc: &'a RenderPipelineDescriptor,
    ) -> ResolvedGeneralRenderPipelineDescriptor<'a> {
        let layout = desc.layout.map(|layout| pipeline_layouts.get(layout));

        let vertex = {
            let module = shader_modules.get(desc.vertex.stage.module);
            let stage = ProgrammableStageDescriptor {
                module,
                entry_point: desc.vertex.stage.entry_point.clone(),
                constants: desc.vertex.stage.constants.clone(),
                zero_initialize_workgroup_memory: true,
            };
            RenderPipelineVertexProcessor::Vertex(pipeline::VertexState {
                stage,
                buffers: desc
                    .vertex
                    .buffers
                    .iter()
                    .map(|v| {
                        v.as_ref().map(|v| pipeline::VertexBufferLayout {
                            array_stride: v.array_stride,
                            step_mode: v.step_mode,
                            attributes: v.attributes.clone(),
                        })
                    })
                    .collect(),
            })
        };

        let fragment = if let Some(ref state) = desc.fragment {
            let module = shader_modules.get(state.stage.module);

            let stage = ProgrammableStageDescriptor {
                module,
                entry_point: state.stage.entry_point.clone(),
                constants: state.stage.constants.clone(),
                zero_initialize_workgroup_memory: true,
            };
            Some(pipeline::FragmentState {
                stage,
                targets: state.targets.clone(),
            })
        } else {
            None
        };

        ResolvedGeneralRenderPipelineDescriptor {
            label: desc.label.clone(),
            layout,
            vertex,
            primitive: desc.primitive,
            depth_stencil: desc.depth_stencil.clone(),
            multisample: desc.multisample,
            fragment,
            multiview_mask: None,
            cache: None,
        }
    }

    pub fn device_create_render_pipeline(
        &self,
        device_id: DeviceId,
        desc: &RenderPipelineDescriptor,
        id_in: id::RenderPipelineId,
    ) {
        let mut hub = self.hub.borrow_mut();

        let Hub {
            shader_modules,
            pipeline_layouts,
            render_pipelines,
            devices,
            ..
        } = &mut *hub;

        let device = devices.get(device_id);

        let desc = Self::resolve_render_pipeline_descriptor(shader_modules, pipeline_layouts, desc);

        let pipeline = device.create_render_pipeline(desc);

        render_pipelines.assign(id_in, pipeline);
    }

    /// Error-returning version of `device_create_render_pipeline` to implement
    /// [GPUDevice.createRenderPipelineAsync](https://gpuweb.github.io/gpuweb/#dom-gpudevice-createrenderpipelineasync).
    /// Returns an error if the pipeline creation fails instead of handling error in device.
    ///
    /// Id is assigned to the pipeline only if the creation succeeds.
    pub fn create_render_pipeline_or_error(
        &self,
        device_id: DeviceId,
        desc: &RenderPipelineDescriptor,
        id_in: id::RenderPipelineId,
    ) -> Result<(), pipeline::CreateRenderPipelineError> {
        let mut hub = self.hub.borrow_mut();
        let Hub {
            render_pipelines,
            devices,
            shader_modules,
            pipeline_layouts,
            ..
        } = &mut *hub;

        let device = devices.get(device_id);

        let desc = Self::resolve_render_pipeline_descriptor(shader_modules, pipeline_layouts, desc);

        match device.create_render_pipeline_or_error(desc) {
            Ok(pipeline) => {
                render_pipelines.assign(id_in, pipeline);
                Ok(())
            }
            Err(e) => Err(e),
        }
    }

    /// Get an ID of one of the bind group layouts. The ID adds a refcount,
    /// which needs to be released by calling `bind_group_layout_drop`.
    pub fn render_pipeline_get_bind_group_layout(
        &self,
        pipeline_id: id::RenderPipelineId,
        index: u32,
        id_in: id::BindGroupLayoutId,
    ) {
        let mut hub = self.hub.borrow_mut();
        let Hub {
            bind_group_layouts,
            render_pipelines,
            ..
        } = &mut *hub;

        let pipeline = render_pipelines.get(pipeline_id);

        let bgl = pipeline.get_bind_group_layout(index);

        bind_group_layouts.assign(id_in, bgl);
    }

    pub fn render_pipeline_remove(
        &self,
        render_pipeline_id: id::RenderPipelineId,
    ) -> Arc<pipeline::RenderPipeline> {
        let mut hub = self.hub.borrow_mut();

        hub.render_pipelines.remove(render_pipeline_id)
    }

    pub fn device_create_compute_pipeline(
        &self,
        device_id: DeviceId,
        desc: &ComputePipelineDescriptor,
        id_in: id::ComputePipelineId,
    ) {
        let mut hub = self.hub.borrow_mut();
        let Hub {
            compute_pipelines,
            devices,
            shader_modules,
            pipeline_layouts,
            ..
        } = &mut *hub;

        let device = devices.get(device_id);

        let layout = desc.layout.map(|layout| pipeline_layouts.get(layout));

        let module = shader_modules.get(desc.stage.module);

        let stage = ProgrammableStageDescriptor {
            module,
            entry_point: desc.stage.entry_point.clone(),
            constants: desc.stage.constants.clone(),
            zero_initialize_workgroup_memory: true,
        };

        let desc = pipeline::ComputePipelineDescriptor {
            label: desc.label.clone(),
            layout,
            stage,
            cache: None,
        };

        let pipeline = device.create_compute_pipeline(desc);

        compute_pipelines.assign(id_in, pipeline);
    }

    /// Error-returning version of `device_create_compute_pipeline` to implement
    /// [GPUDevice.createComputePipelineAsync](https://gpuweb.github.io/gpuweb/#dom-gpudevice-createcomputepipelineasync).
    /// Returns an error if the pipeline creation fails instead of handling error in device.
    ///
    /// Id is assigned to the pipeline only if the creation succeeds.
    pub fn device_create_compute_pipeline_or_error(
        &self,
        device_id: DeviceId,
        desc: &ComputePipelineDescriptor,
        id_in: id::ComputePipelineId,
    ) -> Result<(), pipeline::CreateComputePipelineError> {
        let mut hub = self.hub.borrow_mut();
        let Hub {
            compute_pipelines,
            devices,
            shader_modules,
            pipeline_layouts,
            ..
        } = &mut *hub;

        let device = devices.get(device_id);

        let layout = desc.layout.map(|layout| pipeline_layouts.get(layout));

        let module = shader_modules.get(desc.stage.module);

        let stage = ProgrammableStageDescriptor {
            module,
            entry_point: desc.stage.entry_point.clone(),
            constants: desc.stage.constants.clone(),
            zero_initialize_workgroup_memory: true,
        };

        let desc = pipeline::ComputePipelineDescriptor {
            label: desc.label.clone(),
            layout,
            stage,
            cache: None,
        };

        match device.create_compute_pipeline_or_error(desc) {
            Ok(pipeline) => {
                compute_pipelines.assign(id_in, pipeline);
                Ok(())
            }
            Err(e) => Err(e),
        }
    }

    /// Get an ID of one of the bind group layouts. The ID adds a refcount,
    /// which needs to be released by calling `bind_group_layout_drop`.
    pub fn compute_pipeline_get_bind_group_layout(
        &self,
        pipeline_id: id::ComputePipelineId,
        index: u32,
        id_in: id::BindGroupLayoutId,
    ) {
        let mut hub = self.hub.borrow_mut();
        let Hub {
            bind_group_layouts,
            compute_pipelines,
            ..
        } = &mut *hub;

        let pipeline = compute_pipelines.get(pipeline_id);

        let bgl = pipeline.get_bind_group_layout(index);

        bind_group_layouts.assign(id_in, bgl);
    }

    pub fn compute_pipeline_remove(
        &self,
        compute_pipeline_id: id::ComputePipelineId,
    ) -> Arc<pipeline::ComputePipeline> {
        let mut hub = self.hub.borrow_mut();
        hub.compute_pipelines.remove(compute_pipeline_id)
    }

    /// Check `device_id` for freeable resources and completed buffer mappings.
    pub fn device_poll(
        &self,
        device_id: DeviceId,
        poll_type: wgt::PollType<SubmissionIndex>,
    ) -> Result<wgt::PollStatus, WaitIdleError> {
        let hub = self.hub.borrow();
        let device = hub.devices.get(device_id);

        device.poll(poll_type)
    }

    /// Poll all devices on all backends.
    ///
    /// This is the implementation of `wgpu::Instance::poll_all`.
    ///
    /// Return `all_queue_empty` indicating whether there are more queue
    /// submissions still in flight.
    pub fn poll_all_devices(&self, force_wait: bool) -> Result<bool, WaitIdleError> {
        self.instance.poll_all_devices(force_wait)
    }

    /// # Safety
    ///
    /// - See [wgpu::Device::start_graphics_debugger_capture][api] for details the safety.
    ///
    /// [api]: ../../wgpu/struct.Device.html#method.start_graphics_debugger_capture
    pub unsafe fn device_start_graphics_debugger_capture(&self, device_id: DeviceId) {
        let hub = self.hub.borrow();
        unsafe {
            hub.devices.get(device_id).start_graphics_debugger_capture();
        }
    }

    /// # Safety
    ///
    /// - See [wgpu::Device::stop_graphics_debugger_capture][api] for details the safety.
    ///
    /// [api]: ../../wgpu/struct.Device.html#method.stop_graphics_debugger_capture
    pub unsafe fn device_stop_graphics_debugger_capture(&self, device_id: DeviceId) {
        let hub = self.hub.borrow();
        unsafe {
            hub.devices.get(device_id).stop_graphics_debugger_capture();
        }
    }

    pub fn device_remove(&self, device_id: DeviceId) -> Arc<wgpu_core::device::Device> {
        let mut hub = self.hub.borrow_mut();
        hub.devices.remove(device_id)
    }

    /// `device_lost_closure` might never be called.
    pub fn device_set_device_lost_closure(
        &self,
        device_id: DeviceId,
        device_lost_closure: DeviceLostClosure,
    ) {
        let hub = self.hub.borrow();
        let device = hub.devices.get(device_id);

        device.set_device_lost_closure(device_lost_closure);
    }

    pub fn device_destroy(&self, device_id: DeviceId) {
        let hub = self.hub.borrow();
        let device = hub.devices.get(device_id);

        device.destroy();
    }

    pub fn device_get_internal_counters(&self, device_id: DeviceId) -> wgt::InternalCounters {
        let hub = self.hub.borrow();
        let device = hub.devices.get(device_id);

        device.get_internal_counters()
    }

    pub fn device_generate_allocator_report(
        &self,
        device_id: DeviceId,
    ) -> Option<wgt::AllocatorReport> {
        let hub = self.hub.borrow();
        let device = hub.devices.get(device_id);

        device.generate_allocator_report()
    }

    pub fn queue_remove(&self, queue_id: QueueId) -> Arc<wgpu_core::device::queue::Queue> {
        let mut hub = self.hub.borrow_mut();
        hub.queues.remove(queue_id)
    }

    /// `op.callback` is always called, even in case of errors.
    pub fn buffer_map_async(
        &self,
        buffer_id: id::BufferId,
        offset: BufferAddress,
        size: Option<BufferAddress>,
        op: BufferMapOperation,
    ) -> Option<SubmissionIndex> {
        let hub = self.hub.borrow();

        let buffer = hub.buffers.get(buffer_id);

        buffer.map_async(offset, size, op)
    }

    pub fn buffer_get_mapped_range(
        &self,
        buffer_id: id::BufferId,
        offset: BufferAddress,
        size: Option<BufferAddress>,
    ) -> Result<(NonNull<u8>, u64), BufferAccessError> {
        let hub = self.hub.borrow();

        let buffer = hub.buffers.get(buffer_id);

        buffer.get_mapped_range(offset, size)
    }

    pub fn buffer_unmap(&self, buffer_id: id::BufferId) {
        let hub = self.hub.borrow();

        let buffer = hub.buffers.get(buffer_id);

        buffer.unmap();
    }

    pub fn device_on_uncaptured_error(
        &self,
        device_id: DeviceId,
        handler: Arc<dyn wgt::error::UncapturedErrorHandler>,
    ) {
        let hub = self.hub.borrow();
        let device = hub.devices.get(device_id);

        device.on_uncaptured_error(handler);
    }

    pub fn device_push_error_scope(
        &self,
        device_id: DeviceId,
        error_scope: wgt::error::ErrorFilter,
    ) {
        let hub = self.hub.borrow();
        let device = hub.devices.get(device_id);

        device.push_error_scope(error_scope)
    }

    pub fn device_pop_error_scope(
        &self,
        device_id: DeviceId,
    ) -> Result<Option<wgt::error::Error>, EmptyErrorScopeStack> {
        let hub = self.hub.borrow();
        let device = hub.devices.get(device_id);

        device.pop_error_scope()
    }

    pub fn device_handle_error(
        &self,
        device_id: DeviceId,
        source: impl WebGpuError + Send + Sync + 'static,
        label: Option<&str>,
        fn_ident: &'static str,
    ) {
        let hub = self.hub.borrow();
        let device = hub.devices.get(device_id);

        device.handle_error(source, label, fn_ident);
    }
}