///|
pub(all) enum MeshFormat {
  Obj
  Ply
}

///|
pub struct MeshVertex {
  easting : Double
  northing : Double
  elevation : Double
}

///|
pub struct MeshFace {
  surface_number : Int
  face_number : Int
  vertices : (Int, Int, Int)
}

///|
pub struct TerrainMesh {
  vertices : Array[MeshVertex]
  faces : Array[MeshFace]
  linear_unit : String?
  origin : MeshVertex
}

///|
priv struct MeshBuilder {
  vertices : Array[MeshVertex]
  faces : Array[MeshFace]
  point_indexes : Map[(Int, String), Int]
  face_keys : Map[(Int, Int, Int), Bool]
  origin : MeshVertex
}

///|
fn MeshBuilder::index(
  self : MeshBuilder,
  surface_number : Int,
  point : Point,
) -> Int {
  let key = (surface_number, point.id)
  if self.point_indexes.get(key) is Some(index) {
    return index
  }
  let index = self.vertices.length()
  self.vertices.push({
    easting: point.easting - self.origin.easting,
    northing: point.northing - self.origin.northing,
    elevation: point.elevation - self.origin.elevation,
  })
  self.point_indexes[key] = index
  index
}

///|
/// Builds a visible mesh in X=easting, Y=northing, Z=elevation order.
/// Local origin uses the first vertex of the first visible face.
pub fn build_mesh(
  terrain : Terrain,
  surface_name? : String,
  local_origin? : Bool = false,
) -> TerrainMesh raise SamplingError {
  let mut state : MeshBuilder? = None
  let mut problem = None
  each_visible_triangle(terrain, surface_name, fn(triangle) {
    if problem is Some(_) {
      return
    }
    let builder = match state {
      Some(builder) => builder
      None => {
        let origin = if local_origin {
          MeshVertex::{
            easting: triangle.a.easting,
            northing: triangle.a.northing,
            elevation: triangle.a.elevation,
          }
        } else {
          { easting: 0.0, northing: 0.0, elevation: 0.0, }
        }
        let builder = MeshBuilder::{
          vertices: [],
          faces: [],
          point_indexes: Map([]),
          face_keys: Map([]),
          origin,
        }
        state = Some(builder)
        builder
      }
    }
    let area = projected_area(triangle.a, triangle.b, triangle.c)
    if area <= 0.0 || !finite_sample_value(area) {
      problem = Some(
        "surface '\{triangle.surface_name}': invalid projected area at face #\{triangle.face_number}",
      )
      return
    }
    let surface = triangle.surface_number
    let a = builder.index(surface, triangle.a)
    let b = builder.index(surface, triangle.b)
    let c = builder.index(surface, triangle.c)
    let sorted = [a, b, c]
    sorted.sort()
    let key = (sorted[0], sorted[1], sorted[2])
    if builder.face_keys.contains(key) {
      problem = Some(
        "surface '\{triangle.surface_name}': duplicate face #\{triangle.face_number}",
      )
      return
    }
    builder.face_keys[key] = true
    builder.faces.push({
      surface_number: surface,
      face_number: triangle.face_number,
      vertices: (a, b, c),
    })
  })
  if problem is Some(message) {
    raise InvalidSample(message)
  }
  guard state is Some(builder) else {
    raise InvalidSample("no visible faces to export")
  }
  if builder.vertices.any(fn(vertex) {
      !finite_sample_value(vertex.easting) ||
      !finite_sample_value(vertex.northing) ||
      !finite_sample_value(vertex.elevation)
    }) {
    raise InvalidSample(
      "mesh coordinates exceed the numeric range after origin shift",
    )
  }
  {
    vertices: builder.vertices,
    faces: builder.faces,
    linear_unit: terrain.linear_unit,
    origin: builder.origin,
  }
}

///|
fn TerrainMesh::write_metadata(
  self : TerrainMesh,
  output : StringBuilder,
  prefix : String,
) -> Unit {
  output.write_string("\{prefix} axes easting northing elevation\n")
  output.write_string(
    "\{prefix} origin \{self.origin.easting} \{self.origin.northing} \{self.origin.elevation}\n",
  )
  if self.linear_unit is Some(unit) {
    let safe = StringBuilder()
    for ch in unit {
      if ch >= ' ' && ch != '\u007F' {
        safe.write_char(ch)
      }
    }
    output.write_string("\{prefix} linear_unit \{safe.to_string()}\n")
  }
}

///|
fn TerrainMesh::write_obj(self : TerrainMesh, output : StringBuilder) -> Unit {
  output.write_string("# MoonTIN mesh\n")
  self.write_metadata(output, "#")
  for vertex in self.vertices {
    output.write_string(
      "v \{vertex.easting} \{vertex.northing} \{vertex.elevation}\n",
    )
  }
  let mut group = 0
  for face in self.faces {
    if group != face.surface_number {
      group = face.surface_number
      output.write_string("g surface_\{group}\n")
    }
    let (a, b, c) = face.vertices
    output.write_string("f \{a + 1} \{b + 1} \{c + 1}\n")
  }
}

///|
fn TerrainMesh::write_ply(self : TerrainMesh, output : StringBuilder) -> Unit {
  output.write_string("ply\nformat ascii 1.0\n")
  self.write_metadata(output, "comment")
  output.write_string("element vertex \{self.vertices.length()}\n")
  output.write_string(
    "property double x\nproperty double y\nproperty double z\n",
  )
  output.write_string("element face \{self.faces.length()}\n")
  output.write_string("property list uchar int vertex_indices\n")
  output.write_string(
    "property int surface_number\nproperty int landxml_face_number\nend_header\n",
  )
  for vertex in self.vertices {
    output.write_string(
      "\{vertex.easting} \{vertex.northing} \{vertex.elevation}\n",
    )
  }
  for face in self.faces {
    let (a, b, c) = face.vertices
    output.write_string(
      "3 \{a} \{b} \{c} \{face.surface_number} \{face.face_number}\n",
    )
  }
}

///|
pub fn TerrainMesh::encode(self : TerrainMesh, format : MeshFormat) -> String {
  let output = StringBuilder()
  match format {
    Obj => self.write_obj(output)
    Ply => self.write_ply(output)
  }
  output.to_string()
}