// Port of proj4js 2.22.0's stereographic projections (lib/projections/stere.js,
// sterea.js, gauss.js), MIT License, Copyright (c) 2014 Mike Adair et al.; see NOTICE.

///|
/// Polar or oblique stereographic (`stere`).
priv struct Stere {
  p : Base
  k0 : Double
  coslat0 : Double
  sinlat0 : Double
  con : Double
  cons : Double
  ms1 : Double
  x0_chi : Double
  cos_x0 : Double
  sin_x0 : Double
}

///|
fn ssfn(m : Trig, phit : Double, sinphi : Double, e : Double) -> Double {
  let sinphi = sinphi * e
  m.tan(0.5 * (HALF_PI + phit)) *
  m.pow((1.0 - sinphi) / (1.0 + sinphi), 0.5 * e)
}

///|
fn Stere::new(p : Base, d : Definition) -> Stere {
  let m = p.m
  let coslat0 = m.cos(p.lat0)
  let sinlat0 = m.sin(p.lat0)
  let polar = coslat0.abs() <= EPSLN
  let lat_ts = d.lat_ts
  if p.sphere {
    let k0 = if !lat_ts.is_nan() && polar {
      0.5 * (1.0 + sign(p.lat0) * m.sin(lat_ts))
    } else {
      p.k0
    }
    return {
      p,
      k0,
      coslat0,
      sinlat0,
      con: 0.0,
      cons: 0.0,
      ms1: 0.0,
      x0_chi: 0.0,
      cos_x0: 0.0,
      sin_x0: 0.0,
    }
  }
  let e = p.e
  let con = if p.lat0 > 0.0 { 1.0 } else { -1.0 }
  let cons = (m.pow(1.0 + e, 1.0 + e) * m.pow(1.0 - e, 1.0 - e)).sqrt()
  let k0 = if !lat_ts.is_nan() && polar && m.cos(lat_ts).abs() > EPSLN {
    0.5 *
    cons *
    msfnz(e, m.sin(lat_ts), m.cos(lat_ts)) /
    tsfnz(m, e, con * lat_ts, con * m.sin(lat_ts))
  } else {
    p.k0
  }
  let x0_chi = 2.0 * m.atan(ssfn(m, p.lat0, sinlat0, e)) - HALF_PI
  {
    p,
    k0,
    coslat0,
    sinlat0,
    con,
    cons,
    ms1: msfnz(e, sinlat0, coslat0),
    x0_chi,
    cos_x0: m.cos(x0_chi),
    sin_x0: m.sin(x0_chi),
  }
}

///|
fn Stere::forward(self : Stere, lon : Double, lat : Double) -> (Double, Double) {
  let m = self.p.m
  let p = self.p
  let sinlat = m.sin(lat)
  let coslat = m.cos(lat)
  let dlon = adjust_lon(lon - p.long0)
  if ((lon - p.long0).abs() - PI).abs() <= EPSLN &&
    (lat + p.lat0).abs() <= EPSLN {
    return nan2
  }
  if p.sphere {
    let a = 2.0 *
      self.k0 /
      (1.0 + self.sinlat0 * sinlat + self.coslat0 * coslat * m.cos(dlon))
    return (
      p.a * a * coslat * m.sin(dlon) + p.x0,
      p.a * a * (self.coslat0 * sinlat - self.sinlat0 * coslat * m.cos(dlon)) +
      p.y0,
    )
  }
  let chi = 2.0 * m.atan(ssfn(m, lat, sinlat, p.e)) - HALF_PI
  let cos_x = m.cos(chi)
  let sin_x = m.sin(chi)
  if self.coslat0.abs() <= EPSLN {
    let ts = tsfnz(m, p.e, lat * self.con, self.con * sinlat)
    let rh = 2.0 * p.a * self.k0 * ts / self.cons
    return (
      p.x0 + rh * m.sin(lon - p.long0),
      p.y0 - self.con * rh * m.cos(lon - p.long0),
    )
  }
  if self.sinlat0.abs() < EPSLN {
    let a = 2.0 * p.a * self.k0 / (1.0 + cos_x * m.cos(dlon))
    // proj4js leaves out the false northing here; PROJ adds it.
    (a * cos_x * m.sin(dlon) + p.x0, a * sin_x + p.y0)
  } else {
    let a = 2.0 *
      p.a *
      self.k0 *
      self.ms1 /
      (
        self.cos_x0 *
        (1.0 + self.sin_x0 * sin_x + self.cos_x0 * cos_x * m.cos(dlon))
      )
    (
      a * cos_x * m.sin(dlon) + p.x0,
      a * (self.cos_x0 * sin_x - self.sin_x0 * cos_x * m.cos(dlon)) + p.y0,
    )
  }
}

///|
fn Stere::inverse(self : Stere, 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 {
    let c = 2.0 * m.atan(rh / (2.0 * p.a * self.k0))
    if rh <= EPSLN {
      return (p.long0, p.lat0)
    }
    let lat = m.asin(m.cos(c) * self.sinlat0 + y * m.sin(c) * self.coslat0 / rh)
    let lon = if self.coslat0.abs() < EPSLN {
      if p.lat0 > 0.0 {
        adjust_lon(p.long0 + m.atan2(x, -1.0 * y))
      } else {
        adjust_lon(p.long0 + m.atan2(x, y))
      }
    } else {
      adjust_lon(
        p.long0 +
        m.atan2(
          x * m.sin(c),
          rh * self.coslat0 * m.cos(c) - y * self.sinlat0 * m.sin(c),
        ),
      )
    }
    return (lon, lat)
  }
  if self.coslat0.abs() <= EPSLN {
    if rh <= EPSLN {
      return (p.long0, p.lat0)
    }
    let x = x * self.con
    let y = y * self.con
    let ts = rh * self.cons / (2.0 * p.a * self.k0)
    (
      self.con * adjust_lon(self.con * p.long0 + m.atan2(x, -1.0 * y)),
      self.con * phi2z(m, p.e, ts),
    )
  } else {
    let ce = 2.0 * m.atan(rh * self.cos_x0 / (2.0 * p.a * self.k0 * self.ms1))
    let (lon, chi) = if rh <= EPSLN {
      (p.long0, self.x0_chi)
    } else {
      (
        adjust_lon(
          p.long0 +
          m.atan2(
            x * m.sin(ce),
            rh * self.cos_x0 * m.cos(ce) - y * self.sin_x0 * m.sin(ce),
          ),
        ),
        m.asin(m.cos(ce) * self.sin_x0 + y * m.sin(ce) * self.cos_x0 / rh),
      )
    }
    (lon, -1.0 * phi2z(m, p.e, m.tan(0.5 * (HALF_PI + chi))))
  }
}

///|
/// Oblique stereographic on the Gaussian sphere (`sterea`, as in the
/// Netherlands' RD): the conformal sphere's constants, then its center.
priv struct Sterea {
  p : Base
  c : Double
  k : Double
  ratexp : Double
  phic0 : Double
  sinc0 : Double
  cosc0 : Double
  r2 : Double
}

///|
fn Sterea::new(p : Base) -> Sterea {
  let m = p.m
  let sphi = m.sin(p.lat0)
  let cphi = m.cos(p.lat0)
  let cphi = cphi * cphi
  let rc = (1.0 - p.es).sqrt() / (1.0 - p.es * sphi * sphi)
  let c = (1.0 + p.es * cphi * cphi / (1.0 - p.es)).sqrt()
  let phic0 = m.asin(sphi / c)
  let ratexp = 0.5 * c * p.e
  let k = m.tan(0.5 * phic0 + FORTPI) /
    (m.pow(m.tan(0.5 * p.lat0 + FORTPI), c) * srat(m, p.e * sphi, ratexp))
  {
    p,
    c,
    k,
    ratexp,
    phic0,
    sinc0: m.sin(phic0),
    cosc0: m.cos(phic0),
    r2: 2.0 * rc,
  }
}

///|
fn Sterea::forward(
  self : Sterea,
  lon : Double,
  lat : Double,
) -> (Double, Double) {
  let m = self.p.m
  let p = self.p
  let lon = adjust_lon(lon - p.long0)
  let lat = 2.0 *
    m.atan(
      self.k *
      m.pow(m.tan(0.5 * lat + FORTPI), self.c) *
      srat(m, p.e * m.sin(lat), self.ratexp),
    ) -
    HALF_PI
  let lon = self.c * lon
  let sinc = m.sin(lat)
  let cosc = m.cos(lat)
  let cosl = m.cos(lon)
  let k = p.k0 * self.r2 / (1.0 + self.sinc0 * sinc + self.cosc0 * cosc * cosl)
  (
    p.a * (k * cosc * m.sin(lon)) + p.x0,
    p.a * (k * (self.cosc0 * sinc - self.sinc0 * cosc * cosl)) + p.y0,
  )
}

///|
fn Sterea::inverse(self : Sterea, 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 rho = hypot(x, y)
  let (lon, lat) = if rho != 0.0 {
    let c = 2.0 * m.atan2(rho, self.r2)
    let sinc = m.sin(c)
    let cosc = m.cos(c)
    (
      m.atan2(x * sinc, rho * self.cosc0 * cosc - y * self.sinc0 * sinc),
      m.asin(cosc * self.sinc0 + y * sinc * self.cosc0 / rho),
    )
  } else {
    (0.0, self.phic0)
  }
  let lon = lon / self.c
  let num = m.pow(m.tan(0.5 * lat + FORTPI) / self.k, 1.0 / self.c)
  let mut phi = lat
  let mut settled = false
  for _ in 0..<20 {
    let next = 2.0 * m.atan(num * srat(m, p.e * m.sin(phi), -0.5 * p.e)) -
      HALF_PI
    if (next - phi).abs() < 1.0e-14 {
      phi = next
      settled = true
      break
    }
    phi = next
  }
  if !settled {
    return nan2
  }
  (adjust_lon(lon + p.long0), phi)
}