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

use crate::opengl::currently_bound::CurrentlyBound;

#[derive(Debug)]
pub struct Buffer<Item, ModeT: Mode>
{
    buffer: gl::types::GLuint,
    _item_pd: PhantomData<Item>,
    _mode_pd: PhantomData<ModeT>,
}

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

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

        Self {
            buffer,
            _item_pd: PhantomData,
            _mode_pd: PhantomData,
        }
    }

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

        // SAFETY: The buffer object is bound above
        let currently_bound = unsafe { CurrentlyBound::new() };

        cb(currently_bound);
    }

    /// Stores items in the currently bound buffer.
    pub fn store(_currently_bound: &CurrentlyBound<Self>, items: &[Item], usage: Usage)
    {
        unsafe {
            #[allow(clippy::cast_possible_wrap)]
            gl::BufferData(
                ModeT::GL_ENUM,
                size_of_val(items) as gl::types::GLsizeiptr,
                items.as_ptr().cast(),
                usage.into_gl(),
            );
        }
    }
}

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

/// 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,
        }
    }
}

/// Buffer mode.
pub trait Mode
{
    #[doc(hidden)]
    const GL_ENUM: gl::types::GLenum;
}

/// Array buffer kind.
#[derive(Debug)]
pub struct ArrayKind;

impl Mode for ArrayKind
{
    const GL_ENUM: gl::types::GLenum = gl::ARRAY_BUFFER;
}

/// Element array buffer kind.
#[derive(Debug)]
pub struct ElementArrayKind;

impl Mode for ElementArrayKind
{
    const GL_ENUM: gl::types::GLenum = gl::ELEMENT_ARRAY_BUFFER;
}