use std::marker::PhantomData;
use std::mem::size_of_val;

#[derive(Debug)]
pub struct Buffer<Item>
{
    buf: gl::types::GLuint,
    _pd: PhantomData<Item>,
}

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

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

        Self { buf: buffer, _pd: PhantomData }
    }

    /// Stores items in the currently bound buffer.
    pub fn store(&mut self, items: &[Item], usage: Usage)
    {
        unsafe {
            #[allow(clippy::cast_possible_wrap)]
            gl::NamedBufferData(
                self.buf,
                size_of_val(items) as gl::types::GLsizeiptr,
                items.as_ptr().cast(),
                usage.into_gl(),
            );
        }
    }

    pub fn object(&self) -> gl::types::GLuint
    {
        self.buf
    }
}

impl<Item> Drop for Buffer<Item>
{
    fn drop(&mut self)
    {
        unsafe {
            gl::DeleteBuffers(1, &self.buf);
        }
    }
}

/// Buffer usage.
#[derive(Debug)]
#[allow(dead_code)]
pub enum Usage
{
    /// 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 Usage
{
    fn into_gl(self) -> gl::types::GLenum
    {
        match self {
            Self::Stream => gl::STREAM_DRAW,
            Self::Static => gl::STATIC_DRAW,
            Self::Dynamic => gl::DYNAMIC_DRAW,
        }
    }
}