///|
priv struct GerberRepeat {
  columns : Int32
  rows : Int32
  dx : Double
  dy : Double
  features : Array[GerberFeature]
  mut cost : Int32
}

///|
fn translate_point(point : Point, offset : Point) -> Point {
  { x: point.x + offset.x, y: point.y + offset.y, }
}

///|
fn GerberBounds::translated(
  self : GerberBounds,
  offset : Point,
) -> GerberBounds {
  {
    lower: translate_point(self.lower, offset),
    upper: translate_point(self.upper, offset),
  }
}

///|
fn GerberKind::translated(self : GerberKind, offset : Point) -> GerberKind {
  match self {
    Flash(shape, point) => Flash(shape, translate_point(point, offset))
    Draw(shape, from, to) =>
      Draw(shape, translate_point(from, offset), translate_point(to, offset))
    Arc(arc) => Arc({ ..arc, center: translate_point(arc.center, offset), })
    Region(region) =>
      Region({
        contours: region.contours.map(contour => {
          points: contour.points.map(p => translate_point(p, offset)),
          error: contour.error,
          bounds: contour.bounds.translated(offset),
        }),
        bounds: region.bounds.translated(offset),
      })
  }
}

///|
fn GerberState::emit(
  self : GerberState,
  feature : GerberFeature,
  source : String,
) -> Unit raise GerberError {
  if self.block_stack.get(self.block_stack.length() - 1) is Some(block) {
    self.charge_block(feature, source)
    block.features.push(feature)
    return
  }
  match self.repeat {
    None => self.features.push(feature)
    Some(repeat) => {
      repeat.cost += feature_cost(feature)
      if repeat.cost > self.repeat_budget / (repeat.columns * repeat.rows) {
        raise InvalidGerber(
          source, "SR 展开超出 200000 个对象及轮廓顶点的累计上限",
        )
      }
      repeat.features.push(feature)
    }
  }
}

///|
fn parse_repeat(
  state : GerberState,
  fields : Array[Char],
  statement : String,
  source : String,
) -> Unit raise GerberError {
  if !state.block_stack.is_empty() {
    raise InvalidGerber(source, "AB 块光圈内不能使用 SR 步进重复")
  }
  if fields.is_empty() {
    guard state.repeat is Some(repeat) else {
      raise InvalidGerber(source, "SR 结束指令前没有打开步进重复")
    }
    let copies = repeat.columns * repeat.rows
    state.repeat_budget -= repeat.cost * copies
    if !repeat.features.is_empty() {
      if copies > 1 {
        let mut footprint : GerberBounds? = None
        for item in repeat.features {
          if gerber_object_bounds(item.kind) is Some(bounds) {
            footprint = Some(
              match footprint {
                Some(current) => current.union(bounds)
                None => bounds
              },
            )
          }
        }
        if footprint is Some(footprint) {
          state.panel_grids.push({
            columns: repeat.columns,
            rows: repeat.rows,
            dx: repeat.dx,
            dy: repeat.dy,
            footprint,
          })
        }
      }
      for x in 0.. 1 &&
              item.dark &&
              kind is Flash(_, _) &&
              item.refdes is Some(refdes) {
              state.repeated_refs[designator(refdes)] = true
            }
            state.features.push({ ..item, kind, })
          }
        }
      }
    }
    state.repeat = None
    state.current = None
    return
  }
  if state.repeat is Some(_) {
    raise InvalidGerber(
      source, "SR 必须显式关闭后才能开始另一组重复",
    )
  }
  guard gerber_words(fields)
    is [
      { letter: 'X', value: xs, },
      { letter: 'Y', value: ys, },
      { letter: 'I', value: dx, },
      { letter: 'J', value: dy, },
    ] else {
    raise InvalidGerber(source, "无效的 SR 参数:\{statement}")
  }
  let columns = parse_code({ letter: 'X', value: xs, }, source)
  let rows = parse_code({ letter: 'Y', value: ys, }, source)
  if columns < 1 || rows < 1 || columns > 10000 / rows {
    raise InvalidGerber(
      source, "SR 重复次数必须为正,且每组最多 10000 个单元",
    )
  }
  guard state.scale is Some(unit) else {
    raise InvalidGerber(source, "SR 前缺少 MO 单位声明")
  }
  let dx = aperture_number(dx, source) * unit
  let dy = aperture_number(dy, source) * unit
  if dx < 0.0 ||
    dy < 0.0 ||
    (dx * columns.to_double()).is_inf() ||
    (dy * rows.to_double()).is_inf() {
    raise InvalidGerber(
      source, "SR 步长必须非负,且平移量必须可计算",
    )
  }
  state.repeat = Some({ columns, rows, dx, dy, features: [], cost: 0, })
}