// Port of proj4js 2.22.0's azimuthal projections (lib/projections/aeqd.js,
// laea.js, ortho.js, gnom.js), MIT License, Copyright (c) 2014 Mike Adair et al.; see NOTICE.

///|
/// Azimuthal equidistant: by Vincenty's formulas on the ellipsoid, except
/// at the poles.
priv struct Aeqd {
  p : Base
  sin_p12 : Double
  cos_p12 : Double
  f : Double
  en : (Double, Double, Double, Double)
}

///|
fn Aeqd::new(p : Base) -> Aeqd {
  let m = p.m
  {
    p,
    sin_p12: m.sin(p.lat0),
    cos_p12: m.cos(p.lat0),
    f: p.es / (1.0 + (1.0 - p.es).sqrt()),
    en: mlfn_coefficients(p.es),
  }
}

///|
fn Aeqd::forward(self : Aeqd, lon : Double, lat : Double) -> (Double, Double) {
  let m = self.p.m
  let p = self.p
  let sinphi = m.sin(lat)
  let cosphi = m.cos(lat)
  let dlon = adjust_lon(lon - p.long0)
  let north = (self.sin_p12 - 1.0).abs() <= EPSLN
  let south = (self.sin_p12 + 1.0).abs() <= EPSLN
  if p.sphere {
    if north {
      let r = p.a * (HALF_PI - lat)
      (p.x0 + r * m.sin(dlon), p.y0 - r * m.cos(dlon))
    } else if south {
      let r = p.a * (HALF_PI + lat)
      (p.x0 + r * m.sin(dlon), p.y0 + r * m.cos(dlon))
    } else {
      let cos_c = self.sin_p12 * sinphi + self.cos_p12 * cosphi * m.cos(dlon)
      let c = m.acos(cos_c)
      let kp = if c != 0.0 { c / m.sin(c) } else { 1.0 }
      (
        p.x0 + p.a * kp * cosphi * m.sin(dlon),
        p.y0 +
        p.a * kp * (self.cos_p12 * sinphi - self.sin_p12 * cosphi * m.cos(dlon)),
      )
    }
  } else if north || south {
    let mlp = p.a * mlfn(m, self.en, HALF_PI)
    let ml = p.a * mlfn(m, self.en, lat)
    if north {
      (p.x0 + (mlp - ml) * m.sin(dlon), p.y0 - (mlp - ml) * m.cos(dlon))
    } else {
      (p.x0 + (mlp + ml) * m.sin(dlon), p.y0 + (mlp + ml) * m.cos(dlon))
    }
  } else if lon.abs() < EPSLN && (lat - p.lat0).abs() < EPSLN {
    (p.x0, p.y0)
  } else {
    let (azi1, s12) = vincenty_inverse(
      m,
      p.lat0,
      p.long0,
      lat,
      lon,
      p.a,
      self.f,
    )
    (p.x0 + s12 * m.sin(azi1), p.y0 + s12 * m.cos(azi1))
  }
}

///|
fn Aeqd::inverse(self : Aeqd, x : Double, y : Double) -> (Double, Double) {
  let m = self.p.m
  let p = self.p
  let x = x - p.x0
  let y = y - p.y0
  let rh = (x * x + y * y).sqrt()
  if p.sphere {
    if rh > 2.0 * HALF_PI * p.a {
      return nan2
    }
    let z = rh / p.a
    let sinz = m.sin(z)
    let cosz = m.cos(z)
    if rh.abs() <= EPSLN {
      return (p.long0, p.lat0)
    }
    let lat = asinz(m, cosz * self.sin_p12 + y * sinz * self.cos_p12 / rh)
    let lon = if (p.lat0.abs() - HALF_PI).abs() <= EPSLN {
      if p.lat0 >= 0.0 {
        adjust_lon(p.long0 + m.atan2(x, -y))
      } else {
        adjust_lon(p.long0 - m.atan2(-x, y))
      }
    } else {
      adjust_lon(
        p.long0 +
        m.atan2(x * sinz, rh * self.cos_p12 * cosz - y * self.sin_p12 * sinz),
      )
    }
    (lon, lat)
  } else if (self.sin_p12 - 1.0).abs() <= EPSLN {
    let mlp = p.a * mlfn(m, self.en, HALF_PI)
    (
      adjust_lon(p.long0 + m.atan2(x, -1.0 * y)),
      imlfn(m, (mlp - rh) / p.a, self.en),
    )
  } else if (self.sin_p12 + 1.0).abs() <= EPSLN {
    let mlp = p.a * mlfn(m, self.en, HALF_PI)
    (adjust_lon(p.long0 + m.atan2(x, y)), imlfn(m, (rh - mlp) / p.a, self.en))
  } else {
    let (lat2, lon2) = vincenty_direct(
      m,
      p.lat0,
      p.long0,
      m.atan2(x, y),
      rh,
      p.a,
      self.f,
    )
    (lon2, lat2)
  }
}

///|
/// Lambert azimuthal equal area, in its polar, equatorial or oblique form.
priv struct Laea {
  p : Base
  mode : LaeaMode
  qp : Double
  apa : FixedArray[Double]
  rq : Double
  dd : Double
  xmf : Double
  ymf : Double
  sinb1 : Double
  cosb1 : Double
  sinph0 : Double
  cosph0 : Double
}

///|
/// Which of its forms a Lambert azimuthal equal area takes, by its center.
#derive(Eq)
priv enum LaeaMode {
  SPole
  NPole
  Equit
  Obliq
}

///|
fn Laea::new(p : Base) -> Laea {
  let m = p.m
  let t = p.lat0.abs()
  let mode = if (t - HALF_PI).abs() < EPSLN {
    if p.lat0 < 0.0 {
      SPole
    } else {
      NPole
    }
  } else if t < EPSLN {
    Equit
  } else {
    Obliq
  }
  let l : Laea = {
    p,
    mode,
    qp: 0.0,
    apa: [],
    rq: 0.0,
    dd: 1.0,
    xmf: 1.0,
    ymf: 1.0,
    sinb1: 0.0,
    cosb1: 0.0,
    sinph0: m.sin(p.lat0),
    cosph0: m.cos(p.lat0),
  }
  if p.es <= 0.0 {
    return l
  }
  let qp = qsfnz(m, p.e, 1.0)
  let l = { ..l, qp, apa: authset(p.es), }
  if mode == Equit {
    let rq = (0.5 * qp).sqrt()
    { ..l, rq, dd: 1.0 / rq, xmf: 1.0, ymf: 0.5 * qp, }
  } else if mode == Obliq {
    let rq = (0.5 * qp).sqrt()
    let sinphi = m.sin(p.lat0)
    let sinb1 = qsfnz(m, p.e, sinphi) / qp
    let cosb1 = (1.0 - sinb1 * sinb1).sqrt()
    let dd = m.cos(p.lat0) /
      ((1.0 - p.es * sinphi * sinphi).sqrt() * rq * cosb1)
    { ..l, rq, sinb1, cosb1, dd, xmf: rq * dd, ymf: rq / dd, }
  } else {
    l
  }
}

///|
fn Laea::forward(self : Laea, lon : Double, lat : Double) -> (Double, Double) {
  let m = self.p.m
  let p = self.p
  let lam = adjust_lon(lon - p.long0)
  let mode = self.mode
  let (x, y) = if p.sphere {
    let sinphi = m.sin(lat)
    let cosphi = m.cos(lat)
    let coslam = m.cos(lam)
    if mode == Obliq || mode == Equit {
      let y = if mode == Equit {
        1.0 + cosphi * coslam
      } else {
        1.0 + self.sinph0 * sinphi + self.cosph0 * cosphi * coslam
      }
      if y <= EPSLN {
        return nan2
      }
      let y = (2.0 / y).sqrt()
      (
        y * cosphi * m.sin(lam),
        y *
        (if mode == Equit {
          sinphi
        } else {
          self.cosph0 * sinphi - self.sinph0 * cosphi * coslam
        }),
      )
    } else {
      let coslam = if mode == NPole { -coslam } else { coslam }
      if (lat + p.lat0).abs() < EPSLN {
        return nan2
      }
      let y = FORTPI - lat * 0.5
      let y = 2.0 * (if mode == SPole { m.cos(y) } else { m.sin(y) })
      (y * m.sin(lam), y * coslam)
    }
  } else {
    let coslam = m.cos(lam)
    let sinlam = m.sin(lam)
    let mut q = qsfnz(m, p.e, m.sin(lat))
    let (sinb, cosb) = if mode == Obliq || mode == Equit {
      let sinb = q / self.qp
      (sinb, (1.0 - sinb * sinb).sqrt())
    } else {
      (0.0, 0.0)
    }
    let b = if mode == Obliq {
      1.0 + self.sinb1 * sinb + self.cosb1 * cosb * coslam
    } else if mode == Equit {
      1.0 + cosb * coslam
    } else if mode == NPole {
      q = self.qp - q
      HALF_PI + lat
    } else {
      q = self.qp + q
      lat - HALF_PI
    }
    if b.abs() < EPSLN {
      return nan2
    }
    if mode == Obliq {
      let b = (2.0 / b).sqrt()
      (
        self.xmf * b * cosb * sinlam,
        self.ymf * b * (self.cosb1 * sinb - self.sinb1 * cosb * coslam),
      )
    } else if mode == Equit {
      let b = (2.0 / (1.0 + cosb * coslam)).sqrt()
      (self.xmf * b * cosb * sinlam, b * sinb * self.ymf)
    } else if q >= 0.0 {
      let b = q.sqrt()
      (b * sinlam, coslam * (if mode == SPole { b } else { -b }))
    } else {
      (0.0, 0.0)
    }
  }
  (p.a * x + p.x0, p.a * y + p.y0)
}

///|
fn Laea::inverse(self : Laea, x : Double, y : Double) -> (Double, Double) {
  let m = self.p.m
  let p = self.p
  let mode = self.mode
  let mut x = (x - p.x0) / p.a
  let mut y = (y - p.y0) / p.a
  let (lam, phi) = if p.sphere {
    let rh = (x * x + y * y).sqrt()
    let mut phi = rh * 0.5
    if phi > 1.0 {
      return nan2
    }
    phi = 2.0 * m.asin(phi)
    let sinz = m.sin(phi)
    let cosz = m.cos(phi)
    if mode == Equit {
      phi = if rh.abs() <= EPSLN { 0.0 } else { m.asin(y * sinz / rh) }
      x *= sinz
      y = cosz * rh
    } else if mode == Obliq {
      phi = if rh.abs() <= EPSLN {
        p.lat0
      } else {
        m.asin(cosz * self.sinph0 + y * sinz * self.cosph0 / rh)
      }
      x *= sinz * self.cosph0
      y = (cosz - m.sin(phi) * self.sinph0) * rh
    } else if mode == NPole {
      y = -y
      phi = HALF_PI - phi
    } else {
      phi -= HALF_PI
    }
    let lam = if y == 0.0 && (mode == Equit || mode == Obliq) {
      0.0
    } else {
      m.atan2(x, y)
    }
    (lam, phi)
  } else {
    let mut ab = 0.0
    if mode == Obliq || mode == Equit {
      x /= self.dd
      y *= self.dd
      let rho = (x * x + y * y).sqrt()
      if rho < EPSLN {
        return (p.long0, p.lat0)
      }
      let s_ce = 2.0 * m.asin(0.5 * rho / self.rq)
      let c_ce = m.cos(s_ce)
      let s_ce = m.sin(s_ce)
      x *= s_ce
      if mode == Obliq {
        ab = c_ce * self.sinb1 + y * s_ce * self.cosb1 / rho
        y = rho * self.cosb1 * c_ce - y * self.sinb1 * s_ce
      } else {
        ab = y * s_ce / rho
        y = rho * c_ce
      }
    } else {
      if mode == NPole {
        y = -y
      }
      let q = x * x + y * y
      if q == 0.0 {
        return (p.long0, p.lat0)
      }
      ab = 1.0 - q / self.qp
      if mode == SPole {
        ab = -ab
      }
    }
    (m.atan2(x, y), authlat(m, m.asin(ab), self.apa))
  }
  (adjust_lon(p.long0 + lam), phi)
}

///|
/// Orthographic, and gnomonic (which shares its constants), on a sphere of
/// radius `a`.
priv struct Ortho {
  p : Base
  sin_p14 : Double
  cos_p14 : Double
}

///|
fn Ortho::new(p : Base) -> Ortho {
  let m = p.m
  { p, sin_p14: m.sin(p.lat0), cos_p14: m.cos(p.lat0), }
}

///|
fn Ortho::forward(self : Ortho, lon : Double, lat : Double) -> (Double, Double) {
  let m = self.p.m
  let p = self.p
  let dlon = adjust_lon(lon - p.long0)
  let sinphi = m.sin(lat)
  let cosphi = m.cos(lat)
  let coslon = m.cos(dlon)
  let g = self.sin_p14 * sinphi + self.cos_p14 * cosphi * coslon
  if g > 0.0 || g.abs() <= EPSLN {
    (
      p.x0 + p.a * cosphi * m.sin(dlon),
      p.y0 + p.a * (self.cos_p14 * sinphi - self.sin_p14 * cosphi * coslon),
    )
  } else {
    nan2
  }
}

///|
fn Ortho::inverse(self : Ortho, x : Double, y : Double) -> (Double, Double) {
  let m = self.p.m
  let p = self.p
  let x = x - p.x0
  let y = y - p.y0
  let rh = (x * x + y * y).sqrt()
  let z = asinz(m, rh / p.a)
  let sinz = m.sin(z)
  let cosz = m.cos(z)
  if rh.abs() <= EPSLN {
    return (p.long0, p.lat0)
  }
  let lat = asinz(m, cosz * self.sin_p14 + y * sinz * self.cos_p14 / rh)
  let lon = if (p.lat0.abs() - HALF_PI).abs() <= EPSLN {
    if p.lat0 >= 0.0 {
      adjust_lon(p.long0 + m.atan2(x, -y))
    } else {
      adjust_lon(p.long0 - m.atan2(-x, y))
    }
  } else {
    adjust_lon(
      p.long0 +
      m.atan2(x * sinz, rh * self.cos_p14 * cosz - y * self.sin_p14 * sinz),
    )
  }
  (lon, lat)
}

///|
fn Ortho::gnom_forward(
  self : Ortho,
  lon : Double,
  lat : Double,
) -> (Double, Double) {
  let m = self.p.m
  let p = self.p
  let dlon = adjust_lon(lon - p.long0)
  let sinphi = m.sin(lat)
  let cosphi = m.cos(lat)
  let coslon = m.cos(dlon)
  let g = self.sin_p14 * sinphi + self.cos_p14 * cosphi * coslon
  let x = cosphi * m.sin(dlon)
  let y = self.cos_p14 * sinphi - self.sin_p14 * cosphi * coslon
  if g > 0.0 || g.abs() <= EPSLN {
    (p.x0 + p.a * x / g, p.y0 + p.a * y / g)
  } else {
    let far = 1000.0 * p.a
    (p.x0 + far * x, p.y0 + far * y)
  }
}

///|
fn Ortho::gnom_inverse(
  self : Ortho,
  x : Double,
  y : Double,
) -> (Double, Double) {
  let m = self.p.m
  let p = self.p
  let x = (x - p.x0) / p.a / p.k0
  let y = (y - p.y0) / p.a / p.k0
  let rh = (x * x + y * y).sqrt()
  if rh == 0.0 {
    // proj4js answers with an unset latitude here; PROJ gives the center.
    return (p.long0, p.lat0)
  }
  let c = m.atan2(rh, 1.0)
  let sinc = m.sin(c)
  let cosc = m.cos(c)
  (
    adjust_lon(
      p.long0 +
      m.atan2(x * sinc, rh * self.cos_p14 * cosc - y * self.sin_p14 * sinc),
    ),
    asinz(m, cosc * self.sin_p14 + y * sinc * self.cos_p14 / rh),
  )
}