use integral_geometry::{Point, Rect, Size};

#[derive(Debug)]

pub struct Camera {

    pub position: Point,

    pub zoom: f32,

    size: Size,

}

impl Camera {

    pub fn new() -> Self {

        Self::with_size(Size::new(1024, 768))

    }

    pub fn with_size(size: Size) -> Self {

        Self {

            position: Point::ZERO,

            zoom: 1.0,

            size,

        }

    }

    pub fn viewport(&self) -> Rect {

        #[inline]

        fn scale(value: usize, zoom: f32) -> i32 {

            (value as f32 / zoom / 2.0) as i32

        }

        let half_width = scale(self.size.width, self.zoom);

        let half_height = scale(self.size.height, self.zoom);

        Rect::from_box(

            self.position.x - half_width,

            self.position.x + half_width,

            self.position.y - half_height,

            self.position.y + half_height,

        )

    }

    pub fn projection(&self) -> [f32; 16] {

        let viewport = self.viewport();

        let left = viewport.left() as f32;

        let width = viewport.width() as f32;

        let height = viewport.height() as f32;

        let top = viewport.top() as f32;

        [

            2f32 / width,

            0f32,

            0f32,

            0f32,

            0f32,

            2f32 / -height,

            0f32,

            0f32,

            0f32,

            0f32,

            0.5f32,

            0f32,

            -(2.0 * left + width) / width,

            (2.0 * top + height) / height,

            0.5f32,

            1f32,

        ]

    }

}