//! Types and functions for 2D rendering

use ::{cgmath};

use ::{graphics};

/// Represents a camera ("view") positioned and oriented in a 2D scene with a
/// 2D transformation and a 2D projection
pub struct Camera2d {
  // transform
  /// Position in 2D world space
  pub position                    : cgmath::Point2  <f32>,
  /// Yaw represents a counter-clockwise rotation restricted to the range $[0,
  /// 2\pi)$.
  pub yaw                         : cgmath::Rad     <f32>,
  /// Basis derived from `yaw`.
  pub orientation                 : cgmath::Basis2  <f32>,
  /// Transforms points from 2D world space to 2D camera (view, eye) space as
  /// specified by the camera position and orientation.
  pub transform_mat_world_to_view : cgmath::Matrix4 <f32>,

  // projection
  pub viewport_width              : u16,
  pub viewport_height             : u16,
  /// Determines the extent of the view represented in the `ortho` structure
  pub zoom                        : f32,
  /// Used to create the ortho projection matrix
  pub ortho                       : cgmath::Ortho <f32>,
  /// Constructed from the parameters in `ortho` to transform points in 2D view
  /// space to 4D homogenous clip coordinates.
  pub projection_mat_ortho        : cgmath::Matrix4 <f32>
}

impl Camera2d {
  /// Create a new camera centered at the origin looking down the positive Y
  /// axis with 'up' vector aligned with the Z axis.
  ///
  /// The orthographic projection is defined such that at the initial zoom
  /// level of 1.0, one unit in world space is one *pixel*, so the points in
  /// the bounding rectangle defined by minimum point `(-half_screen_width+1,
  /// -half_screen_height+1)` and maximum point `(half_screen_width,
  /// half_screen_height)` are visible.
  pub fn new (viewport_width : u16, viewport_height : u16) -> Self {
    use cgmath::{One, EuclideanSpace};

    // transform: world space -> view space
    let position    = cgmath::Point2::origin();
    let yaw         = cgmath::Rad (0.0);
    let orientation = cgmath::Basis2::one();
    let transform_mat_world_to_view
      = transform_mat_world_to_view (&position, &orientation);

    // projection: view space -> clip space
    let zoom        = 1.0;
    let ortho       = Self::ortho_from_viewport_zoom (
      viewport_width, viewport_height, zoom);
    let projection_mat_ortho = graphics::projection_mat_orthographic (&ortho);

    Camera2d {
      position,
      yaw,
      orientation,
      transform_mat_world_to_view,
      viewport_width,
      viewport_height,
      zoom,
      ortho,
      projection_mat_ortho
    }
  }

  /// Should be called when the screen resolution changes to update the
  /// orthographic projection state.
  ///
  /// # Panics
  ///
  /// Panics if the viewport width or height are zero:
  ///
  /// ```should_panic
  /// # extern crate gl_utils;
  /// # extern crate cgmath;
  /// # fn main () {
  /// # use gl_utils::Camera2d;
  /// use cgmath::{EuclideanSpace, One, Transform};
  /// let mut camera2d = Camera2d::new (320, 240);
  /// camera2d.set_viewport_dimensions (0, 0); // panics
  /// # }
  /// ```
  pub fn set_viewport_dimensions (&mut self,
    viewport_width : u16, viewport_height : u16
  ) {
    assert!(0 < viewport_width);
    assert!(0 < viewport_height);
    self.viewport_width  = viewport_width;
    self.viewport_height = viewport_height;
    self.compute_ortho();
  }

  /// Set the zoom level.
  ///
  /// # Panics
  ///
  /// Panics if scale factor is zero or negative:
  ///
  /// ```should_panic
  /// # extern crate gl_utils;
  /// # extern crate cgmath;
  /// # fn main () {
  /// # use gl_utils::Camera2d;
  /// use cgmath::{EuclideanSpace, One, Transform};
  /// let mut camera2d = Camera2d::new (320, 240);
  /// camera2d.set_zoom (-1.0);   // panics
  /// # }
  /// ```
  pub fn set_zoom (&mut self, zoom : f32) {
    assert!(0.0 < zoom);
    if self.zoom != zoom {
      self.zoom = zoom;
      self.compute_ortho();
    }
  }

  pub fn rotate (&mut self, delta_yaw : cgmath::Rad <f32>) {
    use std::f32::consts::PI;
    use cgmath::Zero;
    if !delta_yaw.is_zero() {
      self.yaw += delta_yaw;
      if self.yaw < cgmath::Rad (0.0) {
        self.yaw += cgmath::Rad (2.0*PI);
      }
      if cgmath::Rad (2.0*PI) <= self.yaw {
        self.yaw -= cgmath::Rad (2.0*PI);
      }
      self.compute_orientation();
    }
  }

  /// Move by delta X and Y values in local coordinates
  pub fn move_local (&mut self, delta_x : f32, delta_y : f32) {
    self.position += (delta_x * self.orientation.as_ref().x)
        + (delta_y * self.orientation.as_ref().y);
    self.compute_transform();
  }

  /// Multiply the current zoom by the given scale factor.
  ///
  /// # Panics
  ///
  /// Panics if scale factor is zero or negative:
  ///
  /// ```should_panic
  /// # extern crate gl_utils;
  /// # extern crate cgmath;
  /// # fn main () {
  /// # use gl_utils::Camera2d;
  /// use cgmath::{EuclideanSpace, One, Transform};
  /// let mut camera2d = Camera2d::new (320, 240);
  /// camera2d.scale_zoom (-1.0);   // panics
  /// # }
  /// ```
  pub fn scale_zoom (&mut self, scale : f32) {
    assert!(0.0 < scale);
    self.zoom *= scale;
    self.compute_ortho();
  }

  /// Returns the raw *world to view transform* and *ortho projection* matrix
  /// data, suitable for use as shader uniforms.
  #[inline]
  pub fn view_ortho_mats (&self) -> (&[[f32; 4]; 4], &[[f32; 4]; 4]) {
    (
      self.transform_mat_world_to_view.as_ref(),
      self.projection_mat_ortho.as_ref()
    )
  }

  #[inline]
  fn compute_orientation (&mut self) {
    use cgmath::Rotation2;
    self.orientation = cgmath::Basis2::from_angle (self.yaw);
    self.compute_transform();
  }
  #[inline]
  fn compute_transform (&mut self) {
    self.transform_mat_world_to_view
      = transform_mat_world_to_view (&self.position, &self.orientation);
  }
  /// Recomputes the ortho structure based on current viewport and zoom.
  fn compute_ortho (&mut self) {
    self.ortho = Self::ortho_from_viewport_zoom (
      self.viewport_width, self.viewport_height, self.zoom);
    self.compute_projection();
  }
  #[inline]
  fn compute_projection (&mut self) {
    self.projection_mat_ortho
      = graphics::projection_mat_orthographic (&self.ortho);
  }

  /// Rounds the viewport to the next lower even resolution which will
  /// cause 1px distortion but prevent mis-sampling of 2D textures at
  /// non-power-of-two zoom levels
  fn ortho_from_viewport_zoom (
    viewport_width : u16, viewport_height : u16, zoom : f32
  ) -> cgmath::Ortho <f32> {
    let half_scaled_width  = 0.5 * (
      (viewport_width  - viewport_width  % 2) as f32 / zoom);
    let half_scaled_height = 0.5 * (
      (viewport_height - viewport_height % 2) as f32 / zoom);
    cgmath::Ortho {
      left:   -half_scaled_width,
      right:   half_scaled_width,
      bottom: -half_scaled_height,
      top:     half_scaled_height,
      near:   -1.0,
      far:    1.0
    }
  }
}

/// Builds a 4x4 transformation matrix that will transform points in world
/// space coordinates to view space coordinates based on the current 2D view
/// position and orientation.
///
/// The Z coordinate of the position is always `0.0` and the view is always
/// looking down the negative Z axis.
// TODO: doctest ?
pub fn transform_mat_world_to_view (
  view_position    : &cgmath::Point2 <f32>,
  view_orientation : &cgmath::Basis2 <f32>
) -> cgmath::Matrix4 <f32> {
  let eye    = cgmath::Point3::new (view_position.x, view_position.y, 0.0);
  let center = eye - cgmath::Vector3::unit_z();
  let up     = view_orientation.as_ref().y.extend (0.0);
  cgmath::Matrix4::<f32>::look_at (eye, center, up)
}

/// Maps OpenGL NDC coordinates to screen coordinates based on a given screen
/// resolution.
///
/// # Examples
///
/// ```
/// # extern crate gl_utils;
/// # extern crate cgmath;
/// # fn main () {
/// # use gl_utils::camera2d::ndc_2d_to_screen_2d;
/// assert_eq!(
///   ndc_2d_to_screen_2d (cgmath::vec2 (640, 480), (0.0, 0.0).into()),
///   (320, 240).into()
/// );
/// assert_eq!(
///   ndc_2d_to_screen_2d (cgmath::vec2 (640, 480), (0.5, 0.1).into()),
///   (480, 264).into()
/// );
/// assert_eq!(
///   ndc_2d_to_screen_2d (cgmath::vec2 (640, 480), (-1.0, -1.0).into()),
///   (0, 0).into()
/// );
/// assert_eq!(
///   ndc_2d_to_screen_2d (cgmath::vec2 (640, 480), (-1.0, 1.0).into()),
///   (0, 480).into()
/// );
/// assert_eq!(
///   ndc_2d_to_screen_2d (cgmath::vec2 (640, 480), (1.0, -1.0).into()),
///   (640, 0).into()
/// );
/// assert_eq!(
///   ndc_2d_to_screen_2d (cgmath::vec2 (640, 480), (1.0, 1.0).into()),
///   (640, 480).into()
/// );
/// # }
/// ```

pub fn ndc_2d_to_screen_2d (
  screen_dimensions : cgmath::Vector2 <u16>,
  ndc_coord         : cgmath::Point2 <f32>
) -> cgmath::Point2 <i16> {
  cgmath::Point2::new (
    (0.5 * (screen_dimensions.x as f32) * (1.0 + ndc_coord.x)) as i16,
    (0.5 * (screen_dimensions.y as f32) * (1.0 + ndc_coord.y)) as i16)
}

/// Convert screen coordinate to OpenGL NDC based on a given screen resolution.
///
/// # Examples
///
/// ```
/// # extern crate gl_utils;
/// # #[macro_use] extern crate cgmath;
/// # fn main () {
/// # use gl_utils::camera2d::screen_2d_to_ndc_2d;
/// assert_eq!(
///   screen_2d_to_ndc_2d (cgmath::vec2 (640, 480), (320, 240).into()),
///   (0.0, 0.0).into()
/// );
/// assert_relative_eq!(
///   screen_2d_to_ndc_2d (cgmath::vec2 (640, 480), (480, 264).into()),
///   (0.5, 0.1).into()
/// );
/// assert_eq!(
///   screen_2d_to_ndc_2d (cgmath::vec2 (640, 480), (0, 0).into()),
///   (-1.0, -1.0).into()
/// );
/// assert_eq!(
///   screen_2d_to_ndc_2d (cgmath::vec2 (640, 480), (0, 480).into()),
///   (-1.0, 1.0).into()
/// );
/// assert_eq!(
///   screen_2d_to_ndc_2d (cgmath::vec2 (640, 480), (640, 0).into()),
///   (1.0, -1.0).into()
/// );
/// assert_eq!(
///   screen_2d_to_ndc_2d (cgmath::vec2 (640, 480), (640, 480).into()),
///   (1.0, 1.0).into()
/// );
/// # }
/// ```

pub fn screen_2d_to_ndc_2d (
  screen_dimensions : cgmath::Vector2 <u16>,
  screen_coord      : cgmath::Point2 <i16>
) -> cgmath::Point2 <f32> {
  cgmath::Point2::new (
    screen_coord.x as f32 / (0.5 * screen_dimensions.x as f32) - 1.0,
    screen_coord.y as f32 / (0.5 * screen_dimensions.y as f32) - 1.0
  )
}