// p5.Camera (src/webgl/p5.Camera.js). Angles are in radians; the sketch
// converts from its angle mode.

///|
/// A camera: eye, center and up vectors plus a projection.
pub struct Camera {
  mut width : Double
  mut height : Double
  mut camera_type_default : Bool
  mut use_line_perspective : Bool
  camera_matrix : @math.Matrix
  mut proj_matrix : @math.Matrix
  y_scale : Double
  mut eye_x : Double
  mut eye_y : Double
  mut eye_z : Double
  mut center_x : Double
  mut center_y : Double
  mut center_z : Double
  mut up_x : Double
  mut up_y : Double
  mut up_z : Double
  mut camera_fov : Double
  mut aspect_ratio : Double
  mut camera_near : Double
  mut camera_far : Double
  mut default_aspect_ratio : Double
  mut default_eye_z : Double
  mut default_camera_fov : Double
  mut default_camera_near : Double
  mut default_camera_far : Double
}

///|
/// A camera for a `width × height` view with p5's default settings.
pub fn Camera::new(width : Double, height : Double) -> Camera {
  let c : Camera = {
    width,
    height,
    camera_type_default: true,
    use_line_perspective: true,
    camera_matrix: @math.Matrix::new(4),
    proj_matrix: @math.Matrix::new(4),
    y_scale: 1,
    eye_x: 0,
    eye_y: 0,
    eye_z: 0,
    center_x: 0,
    center_y: 0,
    center_z: 0,
    up_x: 0,
    up_y: 1,
    up_z: 0,
    camera_fov: 0,
    aspect_ratio: 1,
    camera_near: 0,
    camera_far: 0,
    default_aspect_ratio: 1,
    default_eye_z: 800,
    default_camera_fov: 0,
    default_camera_near: 0,
    default_camera_far: 0,
  }
  c.compute_default_settings()
  c.set_default_camera()
  c
}

///|
fn Camera::compute_default_settings(self : Camera) -> Unit {
  self.default_aspect_ratio = self.width / self.height
  self.default_eye_z = 800
  self.default_camera_fov = 2.0 *
    js_atan(self.height / 2.0 / self.default_eye_z)
  self.default_camera_near = self.default_eye_z * 0.1
  self.default_camera_far = self.default_eye_z * 10.0
}

///|
fn Camera::set_default_camera(self : Camera) -> Unit {
  self.camera_fov = self.default_camera_fov
  self.aspect_ratio = self.default_aspect_ratio
  self.eye_x = 0
  self.eye_y = 0
  self.eye_z = self.default_eye_z
  self.center_x = 0
  self.center_y = 0
  self.center_z = 0
  self.up_x = 0
  self.up_y = 1
  self.up_z = 0
  self.camera_near = self.default_camera_near
  self.camera_far = self.default_camera_far
  self.perspective()
  self.camera()
  self.camera_type_default = true
}

///|
/// Re-derives the default projection after a canvas resize.
pub fn Camera::resize(self : Camera, width : Double, height : Double) -> Unit {
  self.width = width
  self.height = height
  if self.camera_type_default {
    self.compute_default_settings()
    self.camera_fov = self.default_camera_fov
    self.aspect_ratio = self.default_aspect_ratio
    self.perspective()
  }
}

///|
pub fn Camera::copy(self : Camera) -> Camera {
  {
    ..self,
    camera_matrix: self.camera_matrix.copy(),
    proj_matrix: self.proj_matrix.copy(),
  }
}

///|
/// A perspective projection; omitted values use the defaults.
pub fn Camera::perspective(
  self : Camera,
  fovy? : Double,
  aspect? : Double,
  near? : Double,
  far? : Double,
) -> Unit {
  self.camera_type_default = fovy is None &&
    aspect is None &&
    near is None &&
    far is None
  self.camera_fov = fovy.unwrap_or(self.default_camera_fov)
  let aspect = aspect.unwrap_or(self.default_aspect_ratio)
  let mut near = near.unwrap_or(self.default_camera_near)
  let far = far.unwrap_or(self.default_camera_far)
  if near <= 0.0001 {
    near = 0.01
  }
  self.aspect_ratio = aspect
  self.camera_near = near
  self.camera_far = far
  let f = 1.0 / js_tan(self.camera_fov / 2)
  let nf = 1.0 / (near - far)
  let a = (far + near) * nf
  let b = 2.0 * far * near * nf
  self.proj_matrix = @math.Matrix::from_array([
    f / aspect,
    0,
    0,
    0,
    0,
    -f * self.y_scale,
    0,
    0,
    0,
    0,
    a,
    -1,
    0,
    0,
    b,
    0,
  ])
}

///|
/// An orthographic projection; omitted values fit the canvas.
pub fn Camera::ortho(
  self : Camera,
  left? : Double,
  right? : Double,
  bottom? : Double,
  top? : Double,
  near? : Double,
  far? : Double,
) -> Unit {
  let left = left.unwrap_or(-self.width / 2)
  let right = right.unwrap_or(self.width / 2)
  let bottom = bottom.unwrap_or(-self.height / 2)
  let top = top.unwrap_or(self.height / 2)
  let near = near.unwrap_or(0)
  let far = far.unwrap_or(self.width.max(self.height) + 800)
  self.camera_near = near
  self.camera_far = far
  let w = right - left
  let h = top - bottom
  let d = far - near
  let x = 2.0 / w
  let y = 2.0 / h * self.y_scale
  let z = -2.0 / d
  let tx = -(right + left) / w
  let ty = -(top + bottom) / h
  let tz = -(far + near) / d
  self.proj_matrix = @math.Matrix::from_array([
    x,
    0,
    0,
    0,
    0,
    -y,
    0,
    0,
    0,
    0,
    z,
    0,
    tx,
    ty,
    tz,
    1,
  ])
  self.camera_type_default = false
}

///|
/// A frustum projection; omitted values use p5's defaults.
pub fn Camera::frustum(
  self : Camera,
  left? : Double,
  right? : Double,
  bottom? : Double,
  top? : Double,
  near? : Double,
  far? : Double,
) -> Unit {
  let left = left.unwrap_or(-self.width * 0.05)
  let right = right.unwrap_or(self.width * 0.05)
  let bottom = bottom.unwrap_or(self.height * 0.05)
  let top = top.unwrap_or(-self.height * 0.05)
  let near = near.unwrap_or(self.default_camera_near)
  let far = far.unwrap_or(self.default_camera_far)
  self.camera_near = near
  self.camera_far = far
  let w = right - left
  let h = top - bottom
  let d = far - near
  let x = 2.0 * near / w
  let y = 2.0 * near / h * self.y_scale
  let z = -(2.0 * far * near) / d
  let tx = (right + left) / w
  let ty = (top + bottom) / h
  let tz = -(far + near) / d
  self.proj_matrix = @math.Matrix::from_array([
    x,
    0,
    0,
    0,
    0,
    -y,
    0,
    0,
    tx,
    ty,
    tz,
    -1,
    0,
    0,
    z,
    0,
  ])
  self.camera_type_default = false
}

///|
fn Camera::local_axes(self : Camera) -> (Vec3, Vec3, Vec3) {
  let mut z0 = self.eye_x - self.center_x
  let mut z1 = self.eye_y - self.center_y
  let mut z2 = self.eye_z - self.center_z
  let eye_dist = (z0 * z0 + z1 * z1 + z2 * z2).sqrt()
  if eye_dist != 0 {
    z0 /= eye_dist
    z1 /= eye_dist
    z2 /= eye_dist
  }
  let mut y0 = self.up_x
  let mut y1 = self.up_y
  let mut y2 = self.up_z
  let mut x0 = y1 * z2 - y2 * z1
  let mut x1 = -y0 * z2 + y2 * z0
  let mut x2 = y0 * z1 - y1 * z0
  y0 = z1 * x2 - z2 * x1
  y1 = -z0 * x2 + z2 * x0
  y2 = z0 * x1 - z1 * x0
  let xmag = (x0 * x0 + x1 * x1 + x2 * x2).sqrt()
  if xmag != 0 {
    x0 /= xmag
    x1 /= xmag
    x2 /= xmag
  }
  let ymag = (y0 * y0 + y1 * y1 + y2 * y2).sqrt()
  if ymag != 0 {
    y0 /= ymag
    y1 /= ymag
    y2 /= ymag
  }
  (Vec3::new(x0, x1, x2), Vec3::new(y0, y1, y2), Vec3::new(z0, z1, z2))
}

///|
/// Places the camera; with no arguments, the default camera.
pub fn Camera::camera(
  self : Camera,
  eye? : (Double, Double, Double),
  center? : (Double, Double, Double),
  up? : (Double, Double, Double),
) -> Unit {
  let (ex, ey, ez) = match eye {
    Some(e) => e
    None => (0.0, 0.0, self.default_eye_z)
  }
  let (center, up) = if eye is None {
    (Some((ex, ey, 0.0)), Some((0.0, 1.0, 0.0)))
  } else {
    (center, up)
  }
  self.eye_x = ex
  self.eye_y = ey
  self.eye_z = ez
  if center is Some((cx, cy, cz)) {
    self.center_x = cx
    self.center_y = cy
    self.center_z = cz
  }
  if up is Some((ux, uy, uz)) {
    self.up_x = ux
    self.up_y = uy
    self.up_z = uz
  }
  let (x, y, z) = self.local_axes()
  self.camera_matrix.set_values([
    x.x,
    y.x,
    z.x,
    0,
    x.y,
    y.y,
    z.y,
    0,
    x.z,
    y.z,
    z.z,
    0,
    0,
    0,
    0,
    1,
  ])
  ignore(self.camera_matrix.translate(-ex, -ey, -ez))
}

///|
fn Camera::recamera(
  self : Camera,
  ex : Double,
  ey : Double,
  ez : Double,
  cx : Double,
  cy : Double,
  cz : Double,
) -> Unit {
  self.camera(
    eye=(ex, ey, ez),
    center=(cx, cy, cz),
    up=(self.up_x, self.up_y, self.up_z),
  )
}

///|
/// Points the camera at `(x, y, z)`.
pub fn Camera::look_at(
  self : Camera,
  x : Double,
  y : Double,
  z : Double,
) -> Unit {
  self.recamera(self.eye_x, self.eye_y, self.eye_z, x, y, z)
}

///|
/// Moves the camera along its own axes.
pub fn Camera::move_by(
  self : Camera,
  x : Double,
  y : Double,
  z : Double,
) -> Unit {
  let (lx, ly, lz) = self.local_axes()
  let dx = [lx.x * x, lx.y * x, lx.z * x]
  let dy = [ly.x * y, ly.y * y, ly.z * y]
  let dz = [lz.x * z, lz.y * z, lz.z * z]
  self.recamera(
    self.eye_x + dx[0] + dy[0] + dz[0],
    self.eye_y + dx[1] + dy[1] + dz[1],
    self.eye_z + dx[2] + dy[2] + dz[2],
    self.center_x + dx[0] + dy[0] + dz[0],
    self.center_y + dx[1] + dy[1] + dz[1],
    self.center_z + dx[2] + dy[2] + dz[2],
  )
}

///|
/// Moves the eye to `(x, y, z)` keeping the view direction.
pub fn Camera::set_position(
  self : Camera,
  x : Double,
  y : Double,
  z : Double,
) -> Unit {
  let dx = x - self.eye_x
  let dy = y - self.eye_y
  let dz = z - self.eye_z
  self.recamera(
    x,
    y,
    z,
    self.center_x + dx,
    self.center_y + dy,
    self.center_z + dz,
  )
}

///|
fn Camera::rotate_view(
  self : Camera,
  a : Double,
  x : Double,
  y : Double,
  z : Double,
) -> Unit {
  let cx = self.center_x - self.eye_x
  let cy = self.center_y - self.eye_y
  let cz = self.center_z - self.eye_z
  let r = @math.Matrix::new(4).rotate(a, x, y, z)
  let m = (i : Int32) => r.get(i)
  let rx = cx * m(0) + cy * m(4) + cz * m(8) + self.eye_x
  let ry = cx * m(1) + cy * m(5) + cz * m(9) + self.eye_y
  let rz = cx * m(2) + cy * m(6) + cz * m(10) + self.eye_z
  self.recamera(self.eye_x, self.eye_y, self.eye_z, rx, ry, rz)
}

///|
/// Rotates the view left/right (radians) about the camera's y-axis.
pub fn Camera::pan(self : Camera, angle : Double) -> Unit {
  let (_, y, _) = self.local_axes()
  self.rotate_view(angle, y.x, y.y, y.z)
}

///|
/// Rotates the view up/down (radians) about the camera's x-axis.
pub fn Camera::tilt(self : Camera, angle : Double) -> Unit {
  let (x, _, _) = self.local_axes()
  self.rotate_view(angle, x.x, x.y, x.z)
}

///|
/// Orbits around the center (`_orbit`): azimuth, polar change, and a
/// log10 zoom factor.
pub fn Camera::orbit(
  self : Camera,
  d_theta : Double,
  d_phi : Double,
  d_radius : Double,
) -> Unit {
  let diff = Vec3::new(
    self.eye_x - self.center_x,
    self.eye_y - self.center_y,
    self.eye_z - self.center_z,
  )
  let mut radius = js_hypot3(diff.x, diff.y, diff.z)
  let front = diff.copy().normalize_()
  let up = Vec3::new(self.up_x, self.up_y, self.up_z).normalize_()
  let side = up.cross(front).normalize_()
  let vertical = side.cross(up)
  radius *= @cmath.pow(10, d_radius)
  if radius < self.camera_near {
    radius = self.camera_near
  }
  if radius > self.camera_far {
    radius = self.camera_far
  }
  let phi = js_acos(front.dot(up).clamp(min=-1, max=1)) + d_phi
  if phi <= 0 || phi >= pi {
    self.up_x *= -1
    self.up_y *= -1
    self.up_z *= -1
  }
  ignore(up.mult_(js_cos(phi)))
  ignore(vertical.mult_(js_cos(d_theta) * js_sin(phi)))
  ignore(side.mult_(js_sin(d_theta) * js_sin(phi)))
  let f = up.copy().add_(vertical).add_(side)
  self.eye_x = radius * f.x + self.center_x
  self.eye_y = radius * f.y + self.center_y
  self.eye_z = radius * f.z + self.center_z
  self.recamera(
    self.eye_x,
    self.eye_y,
    self.eye_z,
    self.center_x,
    self.center_y,
    self.center_z,
  )
}

///|
extern "js" fn js_hypot3(x : Double, y : Double, z : Double) -> Double = "Math.hypot"

///|
extern "js" fn js_acos(x : Double) -> Double = "Math.acos"

///|
/// The camera's local axes (x, y, z), each as a tuple.
pub fn Camera::axes(
  self : Camera,
) -> (
  (Double, Double, Double),
  (Double, Double, Double),
  (Double, Double, Double),
) {
  let (x, y, z) = self.local_axes()
  ((x.x, x.y, x.z), (y.x, y.y, y.z), (z.x, z.y, z.z))
}

///|
/// Scales the projection's x/y focal terms (perspective zoom in
/// `orbitControl`).
pub fn Camera::zoom_projection(self : Camera, factor : Double) -> Unit {
  if self.proj_matrix.get(15) == 0 {
    self.proj_matrix.set_element(0, self.proj_matrix.get(0) * factor)
    self.proj_matrix.set_element(5, self.proj_matrix.get(5) * factor)
  }
}