use std::mem::size_of_val;

use crate::opengl::currently_bound::CurrentlyBound;
use crate::vertex::Vertex;

#[derive(Debug)]
pub struct VertexBuffer
{
    buffer: gl::types::GLuint,
}

impl VertexBuffer
{
    pub fn new() -> Self
    {
        let mut buffer = gl::types::GLuint::default();

        unsafe {
            gl::GenBuffers(1, &mut buffer);
        };

        Self { buffer }
    }

    #[allow(clippy::inline_always)]
    #[inline(always)]
    pub fn bind(&self, cb: impl FnOnce(CurrentlyBound<'_, Self>))
    {
        unsafe {
            gl::BindBuffer(gl::ARRAY_BUFFER, self.buffer);
        }

        // SAFETY: A vertex array object is currently bound
        let currently_bound = unsafe { CurrentlyBound::new() };

        cb(currently_bound);
    }

    /// Stores vertices in the currently bound vertex bound.
    pub fn store(
        _currently_bound: &CurrentlyBound<Self>,
        vertices: &[Vertex],
        usage: BufferUsage,
    )
    {
        unsafe {
            #[allow(clippy::cast_possible_wrap)]
            gl::BufferData(
                gl::ARRAY_BUFFER,
                size_of_val(vertices) as gl::types::GLsizeiptr,
                vertices.as_ptr().cast(),
                usage.into_gl(),
            );
        }
    }
}

impl Drop for VertexBuffer
{
    fn drop(&mut self)
    {
        #[allow(clippy::cast_possible_wrap, clippy::cast_possible_truncation)]
        unsafe {
            gl::DeleteBuffers(1, &self.buffer);
        }
    }
}

#[derive(Debug)]
#[allow(dead_code)]
pub enum BufferUsage
{
    /// The buffer data is set only once and used by the GPU at most a few times.
    Stream,

    /// The buffer data is set only once and used many times.
    Static,

    /// The buffer data is changed a lot and used many times.
    Dynamic,
}

impl BufferUsage
{
    fn into_gl(self) -> gl::types::GLenum
    {
        match self {
            Self::Stream => gl::STREAM_DRAW,
            Self::Static => gl::STATIC_DRAW,
            Self::Dynamic => gl::DYNAMIC_DRAW,
        }
    }
}