define_api_id!(0xe0a5_aa39_e06f_6ebd, "render-v1");

pub use super::render_v0::Rectangle;
pub use super::render_v0::SdfHandle;
use crate::FFIResult;
use bytemuck::CheckedBitPattern;
use bytemuck::NoUninit;
use bytemuck::Pod;
use bytemuck::Zeroable;

pub type RenderMeshHandle = u64;

/// A raw handle to a unique resource
///
/// This handle can be retrieved through the Resource Ark API
pub type ResourceHandleRepr = u32;

pub const INVALID_RESOURCE_HANDLE: u32 = !0u32;

/// Mesh component format for a stream
#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq, NoUninit, CheckedBitPattern)]
#[repr(u32)]
pub enum MeshComponentFormat {
    /// 16-bit floating point
    Float16 = 0,
    /// 32-bit floating point
    Float32 = 1,

    /// 8-bit unsigned integer
    UInt8 = 2,
    /// 8-bit signed integer
    SInt8 = 3,

    /// 16-bit unsigned integer
    UInt16 = 4,
    /// 16-bit signed integer
    SInt16 = 5,

    /// 32-bit unsigned integer
    UInt32 = 6,
    /// 32-bit signed integer
    SInt32 = 7,
}

// Mesh stream layout
#[derive(Debug, Copy, Clone, PartialEq, Eq, NoUninit, CheckedBitPattern)]
#[repr(C)]
pub struct MeshStreamLayout {
    pub semantic: MeshStreamSemantic,
    pub component_format: MeshComponentFormat,
    pub component_count: u32,
    pub buffer_ptr: u32,
    pub buffer_size: u32,
}

// Bit flags which are used to tell what optional vertex attributes are used.
bitflags! {
    #[derive(Pod, Zeroable)]
    #[repr(C)]
    pub struct MeshDataInfoFlags : u32 {
        const COLORS = 0b0000_0001;
        const TEX_COORDS = 0b0000_0010;
        const BONE_INDICES_WEIGHTS = 0b0000_0100;
    }
}

impl Default for MeshDataInfoFlags {
    fn default() -> Self {
        Self::empty()
    }
}

// Mesh stream information
#[derive(Debug, Default, Copy, Clone, PartialEq, Eq, Pod, Zeroable)]
#[repr(C)]
pub struct MeshDataInfo {
    pub num_indices: u64,
    pub num_vertices: u64,

    pub flags: MeshDataInfoFlags,
    pub _pad: [u8; 4],
}

// Note: These bitflags are converted to MeshStyleFlags in visual_scene.rs. Also,
// scene_ext_mesh_style::MeshStyleFlags are converted to the same visual_scene MeshStyleFlags. All
// three of these flag types represent roughly the same thing, but with slight tweaks between them,
// and is why there's odd gaps in enum values (another enum may contain a flag in the hole, etc.)
bitflags! {
    #[cfg_attr(feature = "with_serde", derive(serde::Serialize, serde::Deserialize))]
    #[cfg_attr(feature = "with_speedy", derive(speedy::Writable, speedy::Readable))]
    #[repr(C)]
    #[derive(Pod, Zeroable)]
    pub struct RenderMeshStyleFlags : u32 {

        /// Enables lighting.
        const LIGHTING = 0b0000_0001;

        /// Enables lighting based on triangle face normals rather than vertex normals.
        const FLAT_SHADING = 0b0000_0100;

        /// Will make the mesh face the camera at all times, can be handy for things like particles or ui.
        const BILLBOARD = 0b0010_0000;

        /// Two sided - effectively turns off backface culling.
        const TWO_SIDED = 0b0100_0000;

        /// NOTE! Basic renderer only! Will eventually go away!
        ///
        /// If `true`, depth testing is enabled, which means things closer to the camera
        /// will rendered on top of things further away. This is normally what you want.
        ///
        /// If `false`, this instance will be rendered on top of previous instances, even if this instance is further away.
        /// In other words, settings `depth_test=false` will
        /// make your instance visible through all other instances, even if they are not transparent.
        ///
        /// Instances with `depth_test=false` are always rendered last.
        const DEPTH_TEST = 0b1000_0000;

        /// NOTE! Basic renderer only! Will eventually go away!
        /// NOTE! Ignored by mesh rendering, only used by SDF for backwards compatibility reasons.
        ///
        /// Enables writing to the depth buffer.
        /// Control whether or not to write to the depth buffer.
        ///
        /// NOTE: render order is respected, EXCEPT for instances which are transparent or has `depth_test=false`.
        const DEPTH_WRITE = 0b1_0000_0000;
    }
}

impl Default for RenderMeshStyleFlags {
    fn default() -> Self {
        Self::LIGHTING | Self::DEPTH_TEST | Self::DEPTH_WRITE
    }
}

#[derive(Debug, Copy, Clone, Pod, Zeroable)]
#[repr(C)]
pub struct RenderMeshStyle {
    // premultiplied alpha
    pub diffuse_tint: [f32; 4],
    pub flags: RenderMeshStyleFlags,
    pub pad: [u8; 12], // ensure size aligned to 16 bytes
}

impl Default for RenderMeshStyle {
    fn default() -> Self {
        Self {
            diffuse_tint: [1.0, 1.0, 1.0, 1.0],
            flags: Default::default(),
            pad: Default::default(),
        }
    }
}

#[derive(Clone, Copy, Debug, Pod, Zeroable)]
#[repr(C, align(16))]
pub struct RenderMeshInstance {
    // put the matrix first so it's always aligned
    pub world_transform: [f32; 16], // TODO: [f32; 12]
    pub mesh: RenderMeshHandle,
    pub style: RenderMeshStyle,
    pub _pad: [u8; 8],
}

#[derive(Clone, Copy, Debug, Pod, Zeroable)]
#[repr(C, align(16))]
pub struct RenderMeshInstance2 {
    // put the matrix first so it's always aligned
    pub world_transform: [f32; 16], // TODO: [f32; 12]
    pub mesh: RenderMeshHandle,
    pub style: RenderMeshStyle,
    /// Stable instance ID for identifying an instance over frame.
    ///
    /// Value of 0 is treated as no instance ID is used.
    pub instance_id: u64,
    /// The offset used when indexing into an materials overrides array.
    pub materials_offset: u32,
    pub materials_len: u32,
    pub _pad: [u8; 8],
}

#[derive(Clone, Copy, Debug, Pod, Zeroable)]
#[repr(C, align(16))]
pub struct RenderMaterial {
    pub diffuse_albedo: [f32; 3],
    pub alpha: f32,
    pub emissive_color: [f32; 3],
    pub metallic: f32,
    pub perceptual_roughness: f32,
    pub reserved: [f32; 23],
}

impl Default for RenderMaterial {
    fn default() -> Self {
        Self {
            diffuse_albedo: [1.0, 1.0, 1.0],
            alpha: 1.0,
            emissive_color: [0.0, 0.0, 0.0],
            metallic: 0.0,
            perceptual_roughness: 0.5,
            reserved: [0.0; 23],
        }
    }
}

/// Section of a mesh.
///
/// This is a section of the shared geometry, a range of vertices/indices, that have a specific material assigned
/// In glTF this is called a "Primitive"
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
#[repr(C)]
pub struct RenderMeshSection {
    // Range of index buffer covered
    pub start_index: u32,
    pub index_count: u32,
    // Range of vertex buffer covered
    pub start_vertex: u32,
    pub vertex_count: u32,
    // Section specific data
    pub material_index: u32,
}

/// Describes an instance of an Sdf function to be rendered.
#[derive(Debug, Copy, Clone, Pod, Zeroable)]
#[repr(C)]
pub struct SdfInstanceData2 {
    /// Instance space to world transform for the draw call. Column major.
    pub world_from_instance: [f32; 16], // TODO: [f32; 12]

    /// Set this to a stable non-zero value to track the instance across frames
    ///
    /// Needed for correct motion vectors and better tessellation.
    /// 0 means no instance ID, if you really don't have one.
    /// Higher level wrappers should expose this as Option<NonZeroU64>.
    pub instance_id: u64,

    pub bounding_box_index: u32,

    /// Dynamic data for the procedural instance
    ///
    /// Set both to zero in order to render it without modification.
    pub dynamic_data_offset: u32,
    pub dynamic_data_length: u32,

    /// Detail level. 0.0 means automatic detail.
    ///
    /// TODO: Define what this means.
    pub detail_bias: f32,

    /// How to render the tessellated mesh.
    pub style: RenderMeshStyle,

    /// Experience tells me that that we'll need this one day.
    pub reserved: [u32; 4],
}

#[derive(Debug, Copy, Clone, Pod, Zeroable)]
#[repr(C)]
pub struct SkinnedSdfInstanceData2 {
    /// Set this to a stable non-zero value to track the instance across frames
    ///
    /// Needed for correct motion vectors and better tessellation.
    /// 0 means no instance ID, if you really don't have one.
    /// Higher level wrappers should expose this as Option<NonZeroU64>.
    pub instance_id: u64,
    pub detail_bias: f32,
    pub style: RenderMeshStyle,

    /// Experience tells me that that we'll need this one day.
    pub reserved: [u32; 5],
}

/// FFI-safe version of `macaw::IsoTransform`. See macaw's documentation for more information.
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
#[repr(C)]
pub struct RawIsoTransform {
    /// Vec3
    pub translation: [f32; 3],
    /// Quaternion, normalized
    pub rotation: [f32; 4],
}

#[deprecated(note = "Use World API camera instead, this is no longer supported")]
#[derive(Clone, Copy, Debug, NoUninit, CheckedBitPattern)]
#[repr(C)]
pub struct Camera {
    pub view_from_world: RawIsoTransform,
    pub fov_y: f32,
    pub has_viewport: bool,
    pub _pad: [u8; 3],
    pub viewport: Rectangle,
}

/// Global scene rendering parameters.
#[derive(Clone, Copy, Pod, Zeroable)]
#[repr(C)]
pub struct Environment {
    pub sun_dir: [f32; 3],
    pub sun_rgb: [f32; 3],
    pub ground_rgb: [f32; 3],
    pub sky_rgb: [f32; 3],
    pub horizon_rgb: [f32; 3],
    pub fog_density: f32,
    pub fog_height: f32,
    pub fog_height_falloff: f32,
    pub fog_start: f32,
    pub fog_rgba: [f32; 4],
}

#[derive(Debug, Copy, Clone, Pod, Zeroable)]
#[repr(C)]
pub struct Line {
    pub pos0: [f32; 3],
    pub color0: [u8; 4],
    pub pos1: [f32; 3],
    pub color1: [u8; 4],
}

bitflags! {
    #[cfg_attr(feature = "with_serde", derive(serde::Serialize, serde::Deserialize))]
    #[cfg_attr(feature = "with_speedy", derive(speedy::Writable, speedy::Readable))]
    #[repr(C)]
    #[derive(Pod, Zeroable)]
    pub struct GltfFlags : u32 {
        /// Set if vertex colors are in sRGB gamma, otherwise linear gamma assumed
        const VERTEX_COLORS_SRGB = 1;
    }
}

#[ark_api_macros::ark_bindgen(imports = "ark-render-v1")]
mod render {
    use super::*;
    use crate::render_v0::BoundingBox;

    /// Mesh semantic to describe what a stream contains
    #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
    #[repr(u32)]
    pub enum MeshStreamSemantic {
        Indices = 0,            // `u32`
        Positions = 1,          // `[f32; 3]`
        Normals = 2,            // `[f32; 3]`
        Colors = 3,             // `[u8; 4]`
        TexCoords = 4,          // `[f32; 2]`
        BoneIndicesWeights = 5, // `MeshVertexSkinData`: two streams (bone indices and weights) in one as they are always together.
    }

    /// Mesh primitive topology
    #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
    #[repr(u32)]
    pub enum MeshPrimitiveTopology {
        //PointList = 0,
        //LinesList = 1,
        /// Triangle list
        TriangleList = 2,
    }

    extern "C" {
        /// Create a mesh and return a handle to it.
        ///
        /// The mesh can be split into multiple sections with different materials.
        /// If no sections are provided the entire mesh will be a single section.
        /// Note: Colors are assumed to be premultiplied alpha.
        #[with_memory]
        #[deprecated_infallible]
        pub fn create_named_mesh_with_materials_and_sections(
            primitive_topology: MeshPrimitiveTopology,
            streams: &[MeshStreamLayout],
            materials: &[RenderMaterial],
            sections: &[RenderMeshSection],
            name: &str,
        ) -> RenderMeshHandle;

        /// Creates a mesh from an included GLTF file, from the module directory.
        ///
        /// Vertex colors are treated as sRGB.
        pub fn create_mesh_from_gltf(
            gltf_data: &[u8],
            buffer_data: &[u8],
        ) -> FFIResult<RenderMeshHandle>;

        /// Schedule a mesh for destruction.
        ///
        /// The handle will no longer be valid, however, anypending draw calls using the mesh
        /// will still go through. This means, for example, it's valid to create a mesh, draw it,
        /// and destroy it within a single frame.
        #[deprecated_infallible]
        pub fn destroy_mesh(handle: RenderMeshHandle);

        /// Draw a mesh with the specified world transform matrix and mesh style.
        ///
        /// The world transform will be combined with the camera transform.
        ///
        /// If an error occurs drawing one or more of the meshes in the list, *no* meshes in the list
        /// will be drawn, and the module will be aborted.
        #[deprecated_infallible]
        pub fn draw_meshes(mesh_instances: &[RenderMeshInstance]);

        /// Draw a mesh with the specified world transform matrix and mesh style. The world
        /// transform will be combined with the camera transform.
        ///
        /// If an error occurs drawing one or more of the meshes in the list, *no* meshes in the list
        /// will be drawn, and the module will be aborted.
        pub fn draw_meshes2(mesh_instances: &[RenderMeshInstance2]);

        /// Draw a mesh with the specified world transform matrix, mesh style and materials.
        ///
        /// The world transform will be combined with the camera transform.
        ///
        /// If an error occurs drawing one or more of the meshes in the list, *no* meshes in the list
        /// will be drawn, and the module will be aborted.
        pub fn draw_meshes_with_materials(
            mesh_instances: &[RenderMeshInstance2],
            material_overrides: &[RenderMaterial],
        );

        #[deprecated(note = "Use World API camera instead, this is no longer supported")]
        #[deprecated_infallible]
        pub fn set_camera(camera: &Camera);

        /// Draws debug lines.
        #[deprecated_infallible]
        pub fn draw_debug_lines(lines: &[Line]);

        /// Creates a mesh from an included GLTF file, from the module directory.
        ///
        /// Vertex colors are treated as sRGB.
        pub fn create_mesh_from_gltf_with_flags(
            gltf_data: &[u8],
            buffer_data: &[u8],
            flags: u32, // GltfFlags, can't get bitflags! to work with the wrapper.
        ) -> FFIResult<RenderMeshHandle>;

        /// Creates a mesh from an included GLTF file, from the module directory.
        ///
        /// Vertex colors are treated as sRGB.
        pub fn create_mesh_from_gltf_with_flags_name(
            debug_name: &str,
            gltf_data: &[u8],
            buffer_data: &[u8],
            flags: u32, // GltfFlags, can't get bitflags! to work with the wrapper.
        ) -> FFIResult<RenderMeshHandle>;

        /// Creates a mesh directly from GLTF referred to by a resource handle.
        ///
        /// Avoids having to copy the whole GLTF data into module memory.
        pub fn create_mesh_from_gltf_resource(
            debug_name: &str,
            gltf_resource: ResourceHandleRepr,
            gltf_buffer_data: ResourceHandleRepr,
            flags: u32, // GltfFlags, can't get bitflags! to work with the wrapper.
        ) -> FFIResult<RenderMeshHandle>;

        /// Draws 1 or more instances of an SDF model.
        ///
        /// New version that supports the new struct with instance ID.
        #[deprecated_infallible]
        pub fn draw_sdf_model2(
            sdf: SdfHandle,
            instances: &[SdfInstanceData2],
            constants: &[f32],
            bounding_boxes: &[BoundingBox],
        );

        /// Obtain a mesh stream (vertex attributes) from a `RenderMeshHandle`.
        pub fn get_mesh_data_stream(handle: RenderMeshHandle, ty: MeshStreamSemantic) -> Vec<u8>;

        /// Obtain info about the mesh. (Index count, vertex count etc)
        pub fn get_mesh_data_info(handle: RenderMeshHandle) -> MeshDataInfo;

        /// Obtain info about the mesh. (Index count, vertex count etc)
        pub fn get_mesh_data_name(handle: RenderMeshHandle) -> String;
    }
}

pub use render::*;