use std::mem::size_of;

use crate::color::Color;
use crate::vector::Vec3;

#[derive(Debug)]
#[repr(C)]
pub struct Vertex
{
    pos: Vec3<f32>,
    color: Color<f32>,
}

#[derive(Debug, Default)]
pub struct Builder
{
    pos: Option<Vec3<f32>>,
    color: Option<Color<f32>>,
}

impl Builder
{
    #[must_use]
    pub fn new() -> Self
    {
        Self {
            pos: None,
            color: None,
        }
    }

    #[must_use]
    pub fn pos(mut self, pos: Vec3<f32>) -> Self
    {
        self.pos = Some(pos);

        self
    }

    #[must_use]
    pub fn color(mut self, color: Color<f32>) -> Self
    {
        self.color = Some(color);

        self
    }

    #[must_use]
    pub fn build(self) -> Option<Vertex>
    {
        let pos = self.pos?;
        let color = self.color?;

        Some(Vertex { pos, color })
    }
}

impl Vertex
{
    pub(crate) fn attrs() -> &'static [Attribute]
    {
        &[
            Attribute {
                index: 0,
                component_type: AttributeComponentType::Float,
                component_cnt: AttributeComponentCnt::Three,
                component_size: size_of::<f32>(),
            },
            Attribute {
                index: 1,
                component_type: AttributeComponentType::Float,
                component_cnt: AttributeComponentCnt::Three,
                component_size: size_of::<f32>(),
            },
        ]
    }
}

pub(crate) struct Attribute
{
    pub(crate) index: usize,
    pub(crate) component_type: AttributeComponentType,
    pub(crate) component_cnt: AttributeComponentCnt,
    pub(crate) component_size: usize,
}

pub(crate) enum AttributeComponentType
{
    Float,
}

#[derive(Debug, Clone, Copy)]
#[repr(u32)]
#[allow(dead_code)]
pub(crate) enum AttributeComponentCnt
{
    One = 1,
    Two = 2,
    Three = 3,
    Four = 4,
}