// Ports the output-record handling of ClipperBase in Clipper2 2.0.1
// src/clipper.engine.cpp (commit 642390d), Boost Software License 1.0,
// Copyright (c) Angus Johnson 2010-2026. See NOTICE.

///|
fn Clipper64::add_local_min_poly(
  self : Clipper64,
  e1 : Active,
  e2 : Active,
  pt : Point64,
  is_new~ : Bool = false,
) -> OutPt {
  let outrec = self.new_outrec()
  e1.outrec = Some(outrec)
  e2.outrec = Some(outrec)
  if is_open(e1) {
    outrec.owner = None
    outrec.is_open = true
    if e1.wind_dx > 0 {
      set_sides(outrec, e1, e2)
    } else {
      set_sides(outrec, e2, e1)
    }
  } else {
    match get_prev_hot_edge(e1) {
      Some(prev_hot_edge) => {
        if self.using_polytree {
          set_owner(outrec, prev_hot_edge.outrec.unwrap())
        }
        if outrec_is_ascending(prev_hot_edge) == is_new {
          set_sides(outrec, e2, e1)
        } else {
          set_sides(outrec, e1, e2)
        }
      }
      None => {
        outrec.owner = None
        if is_new {
          set_sides(outrec, e1, e2)
        } else {
          set_sides(outrec, e2, e1)
        }
      }
    }
  }
  let op = OutPt::new(pt, outrec)
  outrec.pts = Some(op)
  op
}

///|
fn Clipper64::add_local_max_poly(
  self : Clipper64,
  e1 : Active,
  e2 : Active,
  pt : Point64,
) -> OutPt? {
  if is_joined(e1) {
    self.split(e1, pt)
  }
  if is_joined(e2) {
    self.split(e2, pt)
  }
  if is_front(e1) == is_front(e2) {
    if is_open_end(e1) {
      swap_sides(e1.outrec.unwrap())
    } else if is_open_end(e2) {
      swap_sides(e2.outrec.unwrap())
    } else {
      self.succeeded = false
      return None
    }
  }
  let mut result = self.add_out_pt(e1, pt)
  let or1 = e1.outrec.unwrap()
  let or2 = e2.outrec.unwrap()
  if physical_equal(or1, or2) {
    let outrec = or1
    outrec.pts = Some(result)
    if self.using_polytree {
      match get_prev_hot_edge(e1) {
        None => outrec.owner = None
        Some(e) => set_owner(outrec, e.outrec.unwrap())
      }
    }
    uncouple_outrec(e1)
    result = outrec.pts.unwrap()
    if outrec.owner is Some(o) && o.front_edge is None {
      outrec.owner = get_real_outrec(outrec.owner)
    }
  } else if is_open(e1) {
    if e1.wind_dx < 0 {
      self.join_outrec_paths(e1, e2)
    } else {
      self.join_outrec_paths(e2, e1)
    }
  } else if or1.idx < or2.idx {
    self.join_outrec_paths(e1, e2)
  } else {
    self.join_outrec_paths(e2, e1)
  }
  Some(result)
}

///|
/// Joins `e2`'s outrec path onto `e1`'s and empties `e2`'s.
fn Clipper64::join_outrec_paths(
  self : Clipper64,
  e1 : Active,
  e2 : Active,
) -> Unit {
  ignore(self)
  let or1 = e1.outrec.unwrap()
  let or2 = e2.outrec.unwrap()
  let p1_st = or1.pts.unwrap()
  let p2_st = or2.pts.unwrap()
  let p1_end = p1_st.n()
  let p2_end = p2_st.n()
  if is_front(e1) {
    p2_end.prev = Some(p1_st)
    p1_st.next = Some(p2_end)
    p2_st.next = Some(p1_end)
    p1_end.prev = Some(p2_st)
    or1.pts = Some(p2_st)
    or1.front_edge = or2.front_edge
    if or1.front_edge is Some(f) {
      f.outrec = Some(or1)
    }
  } else {
    p1_end.prev = Some(p2_st)
    p2_st.next = Some(p1_end)
    p1_st.next = Some(p2_end)
    p2_end.prev = Some(p1_st)
    or1.back_edge = or2.back_edge
    if or1.back_edge is Some(b) {
      b.outrec = Some(or1)
    }
  }
  or2.front_edge = None
  or2.back_edge = None
  or2.pts = None
  if is_open_end(e1) {
    or2.pts = or1.pts
    or1.pts = None
  } else {
    set_owner(or2, or1)
  }
  e1.outrec = None
  e2.outrec = None
}

///|
fn Clipper64::new_outrec(self : Clipper64) -> OutRec {
  let result : OutRec = {
    idx: self.outrec_list.length(),
    owner: None,
    front_edge: None,
    back_edge: None,
    pts: None,
    polypath: None,
    splits: None,
    recursive_split: None,
    bounds: { left: 0L, top: 0L, right: 0L, bottom: 0L, },
    path: [],
    is_open: false,
  }
  self.outrec_list.push(result)
  result
}

///|
fn Clipper64::add_out_pt(self : Clipper64, e : Active, pt : Point64) -> OutPt {
  ignore(self)
  let outrec = e.outrec.unwrap()
  let to_front = is_front(e)
  let op_front = outrec.pts.unwrap()
  let op_back = op_front.n()
  if to_front {
    if pt == op_front.pt {
      return op_front
    }
  } else if pt == op_back.pt {
    return op_back
  }
  let new_op = OutPt::new(pt, outrec)
  op_back.prev = Some(new_op)
  new_op.prev = Some(op_front)
  new_op.next = Some(op_back)
  op_front.next = Some(new_op)
  if to_front {
    outrec.pts = Some(new_op)
  }
  new_op
}

///|
fn Clipper64::clean_collinear(self : Clipper64, outrec : OutRec?) -> Unit {
  guard get_real_outrec(outrec) is Some(outrec) && !outrec.is_open else {
    return
  }
  if !is_valid_closed_path(outrec.pts) {
    outrec.pts = None
    return
  }
  let mut start_op = outrec.pts.unwrap()
  let mut op2 = start_op
  while true {
    if is_collinear(op2.p().pt, op2.pt, op2.n().pt) &&
      (
        op2.pt == op2.p().pt ||
        op2.pt == op2.n().pt ||
        !self.preserve_collinear ||
        dot_product(op2.p().pt, op2.pt, op2.n().pt) < 0.0
      ) {
      if outrec.pts is Some(p) && physical_equal(op2, p) {
        outrec.pts = op2.prev
      }
      op2 = dispose_out_pt(op2)
      if !is_valid_closed_path(Some(op2)) {
        outrec.pts = None
        return
      }
      start_op = op2
      continue
    }
    op2 = op2.n()
    if physical_equal(op2, start_op) {
      break
    }
  }
  self.fix_self_intersects(outrec)
}

///|
fn Clipper64::do_split_op(
  self : Clipper64,
  outrec : OutRec,
  split_op : OutPt,
) -> Unit {
  let prev_op = split_op.p()
  let next_next_op = split_op.n().n()
  outrec.pts = Some(prev_op)
  let ip = get_line_intersect_pt(
    prev_op.pt,
    split_op.pt,
    split_op.n().pt,
    next_next_op.pt,
  ).unwrap_or({ x: 0L, y: 0L, })
  let area1 = area_op(prev_op)
  let abs_area1 = area1.abs()
  if abs_area1 < 2.0 {
    outrec.pts = None
    return
  }
  let area2 = area_triangle(ip, split_op.pt, split_op.n().pt)
  let abs_area2 = area2.abs()
  if ip == prev_op.pt || ip == next_next_op.pt {
    next_next_op.prev = Some(prev_op)
    prev_op.next = Some(next_next_op)
  } else {
    let new_op2 = OutPt::new(ip, prev_op.outrec)
    new_op2.prev = Some(prev_op)
    new_op2.next = Some(next_next_op)
    next_next_op.prev = Some(new_op2)
    prev_op.next = Some(new_op2)
  }
  if abs_area2 >= 1.0 &&
    (abs_area2 > abs_area1 || (area2 > 0.0) == (area1 > 0.0)) {
    let new_or = self.new_outrec()
    new_or.owner = outrec.owner
    split_op.outrec = new_or
    split_op.n().outrec = new_or
    let new_op = OutPt::new(ip, new_or)
    new_op.prev = split_op.next
    new_op.next = Some(split_op)
    new_or.pts = Some(new_op)
    split_op.prev = Some(new_op)
    split_op.n().next = Some(new_op)
    if self.using_polytree {
      if path2_contains_path1_op(prev_op, new_op) {
        new_or.splits = Some([outrec])
      } else {
        match outrec.splits {
          Some(s) => s.push(new_or)
          None => outrec.splits = Some([new_or])
        }
      }
    }
  }
}

///|
fn Clipper64::fix_self_intersects(self : Clipper64, outrec : OutRec) -> Unit {
  let mut op2 = outrec.pts.unwrap()
  if physical_equal(op2.p(), op2.n().n()) {
    return
  }
  while true {
    if segments_intersect(op2.p().pt, op2.pt, op2.n().pt, op2.n().n().pt) {
      let pts = outrec.pts.unwrap()
      if physical_equal(op2, pts) || physical_equal(op2.n(), pts) {
        outrec.pts = pts.prev
      }
      self.do_split_op(outrec, op2)
      guard outrec.pts is Some(p) else { break }
      op2 = p
      if physical_equal(op2.p(), op2.n().n()) {
        break
      }
      continue
    } else {
      op2 = op2.n()
    }
    if physical_equal(op2, outrec.pts.unwrap()) {
      break
    }
  }
}

///|
fn update_outrec_owner(outrec : OutRec) -> Unit {
  let start = outrec.pts.unwrap()
  let mut op_curr = start
  while true {
    op_curr.outrec = outrec
    op_curr = op_curr.n()
    if physical_equal(op_curr, start) {
      return
    }
  }
}