// Ported from Draco 1.5.7 (compression/attributes/prediction_schemes/: the delta, parallelogram and
// (constrained) multi-parallelogram decoders): Apache License 2.0, Copyright 2016 The Draco
// Authors. See NOTICE.

///|
/// Prediction methods as Draco numbers them; `PREDICTION_DELTA` also stands for the
/// difference scheme that every other predictor falls back on.
const PREDICTION_DELTA = 0

///|
const PREDICTION_PARALLELOGRAM = 1

///|
const PREDICTION_MULTI_PARALLELOGRAM = 2

///|
const PREDICTION_TEX_COORDS_DEPRECATED = 3

///|
const PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM = 4

///|
const PREDICTION_TEX_COORDS_PORTABLE = 5

///|
const PREDICTION_GEOMETRIC_NORMAL = 6

///|
/// A parent position for the schemes that read one: its portable values, three per entry, and
/// its point-to-value mapping (None for the identity).
priv struct Parent {
  values : FixedArray[Int32]
  map : FixedArray[Int32]?
}

///|
fn Parent::position(
  self : Parent,
  point : Int32,
  out : FixedArray[Int64],
) -> Bool {
  let v = match self.map {
    None => point
    Some(m) => {
      guard point >= 0 && point < m.length() else { return false }
      m[point]
    }
  }
  guard v >= 0 && v < self.values.length() / 3 else { return false }
  out[0] = self.values[3 * v].to_int64()
  out[1] = self.values[3 * v + 1].to_int64()
  out[2] = self.values[3 * v + 2].to_int64()
  true
}

///|
/// A prediction scheme decoder: the scheme's `predictor`, its transform, and for the mesh schemes
/// the corner table and encoding data (`MeshPredictionSchemeData`) with their decoded side data.
priv struct Scheme {
  predictor : Int32
  transform : Transform
  table : Table?
  enc : EncodingData
  mut parent : Parent?
  crease : FixedArray[FixedArray[Bool]]
  mut orientations : FixedArray[Bool]
  mut orientations_left : Int32
  mut orientations_first : Int32
  flip : BitDecoder
  mut normal_mode : Int32
}

///|
fn Scheme::new(
  predictor : Int32,
  transform : Transform,
  table : Table?,
  enc : EncodingData,
  data : FixedArray[Byte],
) -> Scheme {
  {
    predictor,
    transform,
    table,
    enc,
    parent: None,
    crease: FixedArray::make(4, []),
    orientations: [],
    orientations_left: 0,
    orientations_first: 0,
    flip: BitDecoder::new(data),
    normal_mode: 1,
  }
}

///|
fn Scheme::has_parent(self : Scheme) -> Bool {
  self.predictor == PREDICTION_TEX_COORDS_DEPRECATED ||
  self.predictor == PREDICTION_TEX_COORDS_PORTABLE ||
  self.predictor == PREDICTION_GEOMETRIC_NORMAL
}

///|
fn Scheme::num_corners(self : Scheme) -> Int32 {
  match self.table {
    Some(t) => 3 * t.face_count()
    None => 0
  }
}

///|
/// Pops the next orientation (`orientations_.back()`), or None when none is left.
fn Scheme::pop_orientation(self : Scheme) -> Bool? {
  guard self.orientations_left > 0 else { return None }
  self.orientations_left -= 1
  let i = self.orientations_left - self.orientations_first
  guard i >= 0 && i < self.orientations.length() else { return None }
  Some(self.orientations[i])
}

///|
/// The tex coords portable scheme's orientations: `n` bits, of which only the last `keep` can be
/// popped. Once the rANS state stops changing every later bit is the same, so the rest is
/// filled in without decoding them one by one.
fn Scheme::decode_orientations(
  self : Scheme,
  d : BitDecoder,
  n : Int32,
  keep : Int32,
) -> Unit {
  let first = if n > keep { n - keep } else { 0 }
  let out = FixedArray::make(n - first, false)
  let mut last = true
  let mut i = 0
  while i < n {
    let state = d.state
    let offset = d.offset
    let bit = d.bit()
    if !bit {
      last = !last
    }
    if i >= first {
      out[i - first] = last
    }
    i += 1
    if d.state == state && d.offset == offset {
      for j in (if i > first { i } else { first }).. Bool {
  match self.predictor {
    PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM => {
      if b.version < bitstream(2, 2) {
        let mode = b.u8()
        guard !b.failed && mode == 0 else { return false }
      }
      for i in 0..<4 {
        let n = b.varint()
        guard !b.failed else { return false }
        guard !ult(self.num_corners(), n) else { return false }
        if n > 0 {
          let flags = FixedArray::make(n, false)
          self.crease[i] = flags
          let d = BitDecoder::new(b.data)
          guard d.start(b) else { return false }
          for j in 0.. {
      let n = b.u32()
      guard !b.failed && n >= 0 else { return false }
      let d = BitDecoder::new(b.data)
      guard d.start(b) else { return false }
      self.decode_orientations(d, n, self.enc.corners.length())
    }
    PREDICTION_TEX_COORDS_DEPRECATED => {
      let n = if b.version < bitstream(2, 2) { b.u32() } else { b.varint() }
      guard !b.failed else { return false }
      guard n != 0 && !ult(self.num_corners(), n) else { return false }
      let d = BitDecoder::new(b.data)
      guard d.start(b) else { return false }
      self.decode_orientations(d, n, n)
    }
    PREDICTION_GEOMETRIC_NORMAL => {
      guard self.transform.decode_data(b) else { return false }
      if b.version < bitstream(2, 2) {
        let mode = b.u8()
        guard !b.failed && mode <= 1 else { return false }
        self.normal_mode = mode
      }
      return self.flip.start(b)
    }
    _ => ()
  }
  self.transform.decode_data(b)
}

///|
fn vmap_at(enc : EncodingData, v : Int32) -> Int32 {
  if v < 0 || v >= enc.vertex_values.length() {
    0x7fffffff
  } else {
    enc.vertex_values[v]
  }
}

///|
/// `ComputeParallelogramPrediction` into `out[o, o + nc)`.
fn parallelogram(
  id : Int32,
  ci : Int32,
  t : Table,
  enc : EncodingData,
  data : FixedArray[Int32],
  nc : Int32,
  out : FixedArray[Int32],
  o : Int32,
) -> Bool {
  let oci = t.opposite(ci)
  if oci < 0 {
    return false
  }
  let opp = vmap_at(enc, t.vertex(oci))
  let nxt = vmap_at(enc, t.vertex(next(oci)))
  let prv = vmap_at(enc, t.vertex(previous(oci)))
  if opp < id && nxt < id && prv < id {
    for c in 0.. Bool {
  let t = self.transform
  t.init(nc)
  t.compute(FixedArray::make(nc, 0), 0, data, 0, data, 0)
  let mut i = nc
  while i < size {
    t.compute(data, i - nc, data, i, data, i)
    i += nc
  }
  true
}

///|
fn Scheme::parallelograms(
  self : Scheme,
  table : Table,
  data : FixedArray[Int32],
  nc : Int32,
) -> Bool {
  let t = self.transform
  let enc = self.enc
  let n = enc.corners.length()
  let limit = table.face_count() * 3 + 1
  t.init(nc)
  let pred = FixedArray::make(4 * nc, 0)
  let multi = FixedArray::make(nc, 0)
  t.compute(pred, 0, data, 0, data, 0)
  let crease_pos = FixedArray::make(4, 0)
  for p in 1..
        if parallelogram(p, start, table, enc, data, nc, pred, 0) {
          t.compute(pred, 0, data, dst, data, dst)
        } else {
          t.compute(data, src, data, dst, data, dst)
        }
      PREDICTION_MULTI_PARALLELOGRAM => {
        let mut corner = start
        let mut count = 0
        for c in 0..= 0 {
          if parallelogram(p, corner, table, enc, data, nc, pred, 0) {
            for c in 0.. {
        let mut corner = start
        let mut count = 0
        let mut first_pass = true
        let mut steps = 0
        while corner >= 0 {
          if parallelogram(p, corner, table, enc, data, nc, pred, count * nc) {
            count += 1
            if count == 4 {
              break
            }
          }
          corner = if first_pass {
            table.swing_left(corner)
          } else {
            table.swing_right(corner)
          }
          if corner == start {
            break
          }
          if corner < 0 && first_pass {
            first_pass = false
            corner = table.swing_right(start)
          }
          steps += 1
          guard steps <= limit else { return false }
        }
        let mut used = 0
        if count > 0 {
          for c in 0.. Bool {
  guard self.table is Some(table) else { return self.delta(data, size, nc) }
  let per_entry = if self.predictor == PREDICTION_GEOMETRIC_NORMAL ||
    self.predictor == PREDICTION_TEX_COORDS_PORTABLE ||
    self.predictor == PREDICTION_TEX_COORDS_DEPRECATED {
    2
  } else {
    nc
  }
  guard self.enc.corners.length() * per_entry <= size else { return false }
  match self.predictor {
    PREDICTION_GEOMETRIC_NORMAL => self.geometric_normal(table, data, points)
    PREDICTION_TEX_COORDS_PORTABLE | PREDICTION_TEX_COORDS_DEPRECATED =>
      self.tex_coords(table, data, nc, points)
    _ => self.parallelograms(table, data, nc)
  }
}