//! # 🖼️ Unstable Render API

#[doc(hidden)]
pub use crate::ffi::unstable_render::API as FFI_API;

mod ffi {
    pub use crate::ffi::render_v0::*;
    pub use crate::ffi::render_v1::*;
    pub use crate::ffi::unstable_render::*;
}

use crate::render::RenderMesh;
use crate::render::RenderMeshInstance;
use crate::render::RenderMeshInstanceBuilder;
use crate::render::RenderMeshStyle;
use crate::Error;
use macaw::Mat4;

/// Gives access to unstable rendering specific functionality like drawing 2D triangles.
///
/// Use the `require_unstable_render_api` macro's `unstable_render()` function to get an instance of [`UnstableRender`].
/// See the module level documentation for an example.
///
/// A `UnstableRender` object can be cheaply cloned.
#[derive(Copy, Clone)]
pub struct UnstableRender {
    _private: (),
}

impl UnstableRender {
    #[doc(hidden)]
    pub fn __create() -> Self {
        Self { _private: () }
    }

    /// Execute a compute shader that generates a mesh and writes it to the output `RenderGpuMesh`.
    /// If no thread count is provided the thread count will be `(output_mesh_vertex_count, 1, 1)`.
    pub fn execute_compute_mesh(
        &self,
        shader: &RenderShader,
        input_mesh: Option<&RenderMesh>,
        input_buffers: &[&RenderGpuBuffer],
        push_constants: &[u8],
        output: &RenderGpuMesh,
        thread_count: Option<(u32, u32, u32)>,
    ) -> Result<(), Error> {
        let inputs = if let Some(input) = input_mesh {
            vec![input.raw_handle()]
        } else {
            vec![]
        };

        let thread_count = if let Some(thread_count) = thread_count {
            vec![thread_count.0, thread_count.1, thread_count.2]
        } else {
            vec![]
        };

        let input_buffers: Vec<_> = input_buffers.iter().map(|m| m.handle).collect();

        Ok(ffi::execute_compute_mesh(
            shader.handle,
            &inputs,
            &input_buffers,
            push_constants,
            &[output.handle],
            &thread_count,
        )?)
    }

    /// Execute a compute shader that does not generate any mesh
    pub fn execute_compute(
        &self,
        shader: &RenderShader,
        input_buffers: &[&RenderGpuBuffer],
        push_constants: &[u8],
        thread_count: (u32, u32, u32),
    ) -> Result<(), Error> {
        let input_buffers: Vec<_> = input_buffers.iter().map(|m| m.handle).collect();

        Ok(ffi::execute_compute_mesh(
            shader.handle,
            &[],
            &input_buffers,
            push_constants,
            &[],
            &[thread_count.0, thread_count.1, thread_count.2],
        )?)
    }

    /// Create a gpu mesh
    pub fn create_gpu_mesh(
        &self,
        num_vertices: u32,
        num_indices: u32,
        num_materials: u32,
    ) -> Result<RenderGpuMesh, Error> {
        Ok(RenderGpuMesh::new(ffi::create_gpu_mesh(
            num_vertices,
            num_indices,
            num_materials,
        )?))
    }

    /// Create a gpu mesh from existing mesh
    pub fn create_gpu_mesh_from_mesh(
        &self,
        input_mesh: &RenderMesh,
    ) -> Result<RenderGpuMesh, Error> {
        Ok(RenderGpuMesh::new(ffi::create_gpu_mesh_from_mesh(
            input_mesh.raw_handle(),
        )?))
    }

    /// Create a gpu buffer
    pub fn create_gpu_buffer(&self, data: &[u8]) -> Result<RenderGpuBuffer, Error> {
        Ok(RenderGpuBuffer::new(ffi::create_gpu_buffer(data)?))
    }

    /// Create a shader
    pub fn create_shader(&self, entry: &str, spirv: &[u8]) -> Result<RenderShader, Error> {
        Ok(RenderShader::new(ffi::create_shader(entry, spirv)?))
    }
}

/// Render Gpu Mesh
///
/// A mesh generated on the GPU.
/// This mesh is not readable from the CPU directly.
pub struct RenderGpuMesh {
    pub(crate) handle: ffi::RenderMeshHandle,
}

impl Drop for RenderGpuMesh {
    fn drop(&mut self) {
        ffi::destroy_gpu_mesh(self.handle);
    }
}

impl RenderGpuMesh {
    fn new(handle: ffi::RenderMeshHandle) -> Self {
        Self { handle }
    }
}

/// GPU Buffer
///
/// Can be used as input and output data for compute work.
pub struct RenderGpuBuffer {
    handle: ffi::RenderGpuBufferHandle,
}

impl Drop for RenderGpuBuffer {
    fn drop(&mut self) {
        ffi::destroy_gpu_buffer(self.handle);
    }
}

impl RenderGpuBuffer {
    fn new(handle: ffi::RenderGpuBufferHandle) -> Self {
        Self { handle }
    }
}

/// Shader
///
/// Currently only used for compute work where it can generate meshes and drawcalls on the GPU.
pub struct RenderShader {
    handle: ffi::RenderShaderHandle,
}

impl Drop for RenderShader {
    fn drop(&mut self) {
        ffi::destroy_shader(self.handle);
    }
}

impl RenderShader {
    fn new(handle: ffi::RenderShaderHandle) -> Self {
        Self { handle }
    }
}

/// Wrapper over `RenderMeshInstanceBuilder` to allow creating a instance from a gpu mesh.
/// The instance isn't a breaking change. once the api is stabalized the `new_gpu` function can be part of v1.
#[derive(Debug, Clone)]
pub struct UnstableRenderMeshInstanceBuilder {}

impl UnstableRenderMeshInstanceBuilder {
    /// Creates a new builder from a [`RenderGpuMesh`].
    pub fn new_gpu(mesh: &crate::unstable_render::RenderGpuMesh) -> RenderMeshInstanceBuilder {
        RenderMeshInstanceBuilder {
            inst: RenderMeshInstance {
                world_transform: Mat4::IDENTITY.to_cols_array(),
                mesh: mesh.handle,
                style: RenderMeshStyle::default().into(),
                instance_id: 0,
                materials_offset: 0,
                materials_len: 0,
                mesh_styles_index: 0,
                _pad: [0; 4],
            },
        }
    }
}