///|
priv struct BoundaryLink {
  neighbor : String
  face_number : Int
}

///|
priv struct BoundarySummary {
  closed_loops : Int
  branched_components : Int
}

///|
fn SurfaceTopology::check_boundary(
  self : SurfaceTopology,
  emit : (Rule, Int?, Array[String], Array[Int]) -> Unit,
) -> BoundarySummary {
  let adjacency : Map[String, Array[BoundaryLink]] = Map([])
  let nonmanifold_vertices : Map[String, Bool] = Map([])
  self.edges.each(fn(edge, uses) {
    let (a, b) = edge
    if uses is [usage] {
      add_boundary_link(adjacency, a, b, usage.face_number)
      add_boundary_link(adjacency, b, a, usage.face_number)
    } else if uses.length() > 2 {
      nonmanifold_vertices[a] = true
      nonmanifold_vertices[b] = true
    }
  })
  let visited : Map[String, Bool] = Map([])
  let mut closed_loops = 0
  let mut branched_components = 0
  adjacency.each(fn(start, _) {
    if !visited.contains(start) {
      let pending = [start]
      visited[start] = true
      let mut closed = true
      while pending.pop() is Some(point) {
        let links = adjacency[point]
        if links.length() != 2 {
          closed = false
        }
        if links.length() != 2 && !nonmanifold_vertices.contains(point) {
          let faces = Map([])
          for link in links {
            faces[link.face_number] = true
          }
          let numbers = []
          faces.each(fn(number, _) { numbers.push(number) })
          numbers.sort()
          emit(
            BranchingBoundary,
            Some(numbers[0]),
            [point],
            numbers[1:].to_owned(),
          )
        }
        for link in links {
          if !visited.contains(link.neighbor) {
            visited[link.neighbor] = true
            pending.push(link.neighbor)
          }
        }
      }
      if closed {
        closed_loops += 1
      } else {
        branched_components += 1
      }
    }
  })
  { closed_loops, branched_components, }
}

///|
fn add_boundary_link(
  adjacency : Map[String, Array[BoundaryLink]],
  point : String,
  neighbor : String,
  face_number : Int,
) -> Unit {
  let link = BoundaryLink::{ neighbor, face_number, }
  match adjacency.get(point) {
    Some(links) => links.push(link)
    None => adjacency[point] = [link]
  }
}