// Port of `PrimitiveToVerticesConverter` (src/shape/custom_shapes.js): the
// WEBGL renderer turns shapes into vertex lists, sampling curves.

///|
fn pt_array(p : Pt) -> Array[Double] {
  let a = [p.x, p.y, p.z]
  for v in p.extra {
    a.push(v)
  }
  a
}

///|
fn array_pt(a : Array[Double]) -> Pt {
  {
    x: a[0],
    y: a[1],
    z: a[2],
    extra: FixedArray::makei(a.length() - 3, i => a[i + 3]),
  }
}

///|
fn pt_dist(a : Pt, b : Pt) -> Double {
  let dx = a.x - b.x
  let dy = a.y - b.y
  let dz = a.z - b.z
  (dx * dx + dy * dy + dz * dz).sqrt()
}

///|
fn polyline_length(pts : Array[Pt]) -> Double {
  let mut len = 0.0
  for i in 1.. Array[Double] {
  let s0 = @cmath.pow(1 - t, 3)
  let s1 = 3.0 * @cmath.pow(1 - t, 2) * t
  let s2 = 3.0 * (1 - t) * @cmath.pow(t, 2)
  let s3 = @cmath.pow(t, 3)
  [
    for i, v in ps[0] => v * s0 + ps[1][i] * s1 + ps[2][i] * s2 + ps[3][i] * s3
  ]
}

///|
fn quadratic_arrays(ps : Array[Array[Double]], t : Double) -> Array[Double] {
  let s0 = @cmath.pow(1 - t, 2)
  let s1 = 2.0 * (1 - t) * t
  let s2 = t * t
  [
    for i, v in ps[0] => v * s0 + ps[1][i] * s1 + ps[2][i] * s2
  ]
}

///|
/// The shape as lists of vertices, one per contour or primitive, with
/// curves sampled at `curve_detail` points per unit of hull length.
pub fn Shape::to_vertices(
  self : Shape,
  curve_detail~ : Double = 1,
  points_to_lines~ : Bool = true,
) -> Array[Array[Pt]] {
  let out : Array[Array[Pt]] = []
  let last = () => out[out.length() - 1]
  for contour in self.contours {
    for index, prim in contour.primitives {
      let v = prim.vertices
      match prim.kind {
        Anchor => {
          out.push([])
          let next = contour.primitives.get(index + 1)
          match next {
            Some(n) if n.kind is SplineSegment && n.spline_ends is Exclude => {
              let first = if comes_after_segment(contour, index + 1) {
                n.vertices[1]
              } else {
                n.vertices[0]
              }
              last().push(first)
            }
            _ => last().push(v[v.length() - 1])
          }
        }
        LineSegment => last().append(v)
        // an unfinished curve (too few control points) is skipped, as the
        // 2D path does
        BezierSegment(order) if v.length() < order => ()
        BezierSegment(order) => {
          let start = start_vertex(contour, index)
          let hull = [start]
          hull.append(v)
          let n = @cmath.ceil(polyline_length(hull) * curve_detail)
            .to_int()
            .max(1)
          let arrays = hull.map(pt_array)
          for i in 0.. {
          let after_segment = comes_after_segment(contour, index)
          let start = start_vertex(contour, index)
          let points : Array[Pt] = []
          if after_segment {
            points.push(start)
          }
          points.push(start)
          points.append(v)
          match prim.spline_ends {
            Include => {
              points.insert(0, start)
              points.push(v[v.length() - 1])
            }
            Join => {
              points.insert(0, v[v.length() - 1])
              points.push(start)
              points.push(v[0])
            }
            Exclude => ()
          }
          let arrays = points.map(pt_array)
          let s = 1.0 - prim.spline_tightness
          let mut first = match prim.spline_ends {
            Exclude => pt_array(if after_segment { v[1] } else { v[0] })
            _ => pt_array(start)
          }
          for i = 0; i + 3 < arrays.length(); i = i + 1 {
            let a = arrays[i]
            let b = arrays[i + 1]
            let c = arrays[i + 2]
            let d = arrays[i + 3]
            let bez_b = [ for k, bv in b => bv + (c[k] - a[k]) * (s / 6) ]
            let bez_c = [ for k, cv in c => cv + (b[k] - d[k]) * (s / 6) ]
            let controls = [first, bez_b, bez_c, c]
            let n = @cmath.ceil(
                polyline_length(controls.map(array_pt)) * curve_detail,
              )
              .to_int()
              .max(1)
            for j in 0..
          for p in v {
            out.push(if points_to_lines { [p, p] } else { [p] })
          }
        LineP
        | TriangleP
        | QuadP
        | TriangleFanP
        | TriangleStripP
        | QuadStripP => out.push(v.copy())
        ArcP(x, y, w, h, start, stop, mode) => {
          let s = v[0]
          let e = v[v.length() - 1]
          let cx = x + w / 2
          let cy = y + h / 2
          let rx = w / 2
          let ry = h / 2
          let arc_len = (rx + ry) / 2 * (stop - start).abs()
          let n = @cmath.ceil(curve_detail * arc_len).to_int().max(3)
          let lerp_extra = (t : Double) => {
            FixedArray::makei(s.extra.length(), k => {
              s.extra[k] * (1 - t) + e.extra.get(k).unwrap_or(0) * t
            })
          }
          let verts : Array[Pt] = []
          if mode is Some(Pie) {
            verts.push({ x: cx, y: cy, z: 0, extra: lerp_extra(0.5), })
          }
          for i in 0..<=n {
            let t = i.to_double() / n.to_double()
            let angle = start + (stop - start) * t
            verts.push({
              x: cx + rx * @cmath.cos(angle),
              y: cy + ry * @cmath.sin(angle),
              z: 0,
              extra: lerp_extra(t),
            })
          }
          out.push(verts)
        }
        EllipseP(_) | RectP(_) => ()
      }
    }
  }
  out
}

///|
/// The kind of the first contour (p5's `shape.contours[0].kind`).
pub fn Shape::first_contour_kind(self : Shape) -> ShapeKind {
  match self.contours.get(0) {
    Some(c) => c.kind
    None => self.kind
  }
}