use crate::builder;
use crate::data_types::dimens::Dimens;
use crate::matrix::Matrix;
use crate::vector::Vec2;

#[derive(Debug, Clone)]
#[non_exhaustive]
pub enum Projection
{
    Perspective(Perspective),
    Orthographic(Orthographic),
}

/// Perspective projection parameters.
#[derive(Debug, Clone)]
pub struct Perspective
{
    pub fov_radians: f32,
    pub far: f32,
    pub near: f32,
}

impl Perspective
{
    /// Creates a perspective projection matrix using right-handed coordinates.
    #[inline]
    pub fn to_matrix_rh(&self, aspect: f32, clip_volume: ClipVolume)
    -> Matrix<f32, 4, 4>
    {
        let mut out = Matrix::new();

        match clip_volume {
            ClipVolume::NegOneToOne => {
                out.set_cell(0, 0, (1.0 / (self.fov_radians / 2.0).tan()) / aspect);
                out.set_cell(1, 1, 1.0 / (self.fov_radians / 2.0).tan());
                out.set_cell(2, 2, (self.near + self.far) / (self.near - self.far));
                out.set_cell(2, 3, (2.0 * self.near * self.far) / (self.near - self.far));
                out.set_cell(3, 2, -1.0);
            }
        }

        out
    }
}

impl Default for Perspective
{
    fn default() -> Self
    {
        Self {
            fov_radians: 80.0f32.to_radians(),
            far: 100.0,
            near: 0.1,
        }
    }
}

#[derive(Debug, Clone)]
pub enum OrthographicSize
{
    FixedSize(Dimens<f32>),
    WindowSize,
}

builder! {
#[builder(name = OrthographicBuilder, derives=(Debug, Clone))]
#[derive(Debug, Clone)]
#[non_exhaustive]
pub struct Orthographic
{
    pub near: f32,
    pub far: f32,
    pub viewport_origin: Vec2<f32>,
    pub size: OrthographicSize,
}
}

impl Orthographic
{
    pub fn builder() -> OrthographicBuilder
    {
        OrthographicBuilder::default()
    }

    /// Creates a orthographic projection matrix using right-handed coordinates.
    pub fn to_matrix_rh(
        &self,
        window_size: Dimens<f32>,
        clip_volume: ClipVolume,
    ) -> Matrix<f32, 4, 4>
    {
        let mut result = Matrix::<f32, 4, 4>::new();

        let size = match self.size {
            OrthographicSize::FixedSize(fixed_size) => fixed_size,
            OrthographicSize::WindowSize => window_size,
        };

        let origin_x = size.width * self.viewport_origin.x;
        let origin_y = size.height * self.viewport_origin.y;

        let left = -origin_x;
        let right = size.width - origin_x;

        let bottom = -origin_y;
        let top = size.height - origin_y;

        let near = self.near;
        let far = self.far;

        match clip_volume {
            ClipVolume::NegOneToOne => {
                result.set_cell(0, 0, 2.0 / (right - left));
                result.set_cell(1, 1, 2.0 / (top - bottom));
                result.set_cell(2, 2, -2.0 / (far - near));
                result.set_cell(0, 3, -(right + left) / (right - left));
                result.set_cell(1, 3, -(top + bottom) / (top - bottom));
                result.set_cell(2, 3, -(far + near) / (far - near));
                result.set_cell(3, 3, 1.0);
            }
        }

        result
    }
}

impl Default for Orthographic
{
    fn default() -> Self
    {
        Self::builder().build()
    }
}

impl Default for OrthographicBuilder
{
    fn default() -> Self
    {
        Self {
            near: 0.0,
            far: 1000.0,
            viewport_origin: Vec2 { x: 0.5, y: 0.5 },
            size: OrthographicSize::WindowSize,
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[non_exhaustive]
pub enum ClipVolume
{
    /// -1 to +1. This is the OpenGL clip volume definition.
    NegOneToOne,
}