use std::time::Instant;

use glc::{
    buffer::{Buffer, Target, Usage},
    error::Error,
};

pub struct Uniform {
    buffer: Buffer,
    start_time: Instant,
    last_time: Instant,
}

#[repr(C, packed)]
struct Data {
    time: f32,
    delta: f32,
}

impl Uniform {
    pub fn new() -> Result<Self, Error> {
        let mut buffer = Buffer::new()?;
        buffer.buffer_data(
            Usage::StaticDraw,
            &[Data {
                time: 0.0,
                delta: 0.0,
            }],
        )?;

        let now = Instant::now();

        Ok(Self {
            buffer,
            start_time: now,
            last_time: now,
        })
    }

    pub fn update(&mut self) -> Result<(), Error> {
        let now = Instant::now();
        let time = now.duration_since(self.start_time).as_secs_f32();
        let delta = now.duration_since(self.last_time).as_secs_f32();

        self.last_time = now;

        let mut data = self.buffer.map_mut::<Data>(true)?;

        data[0].time = time;
        data[0].delta = delta;

        Ok(())
    }

    pub fn bind(&self, index: gl::GLuint) -> Result<(), Error> {
        Error::checked(|| self.buffer.bind_buffer_base(Target::UniformBuffer, index))
    }
}