package halfedge

Vec3 :: [3]f32

Vertex :: struct {
	pos:  Vec3,
	edge: Edge_Index,
}

Face :: struct {
	edge: Edge_Index,
}

Vertex_Index :: distinct u16
Face_Index :: distinct u16
Edge_Index :: distinct i16

Half_Edge :: struct {
	origin: Vertex_Index,
	twin:   Edge_Index,
	face:   Face_Index,
	next:   Edge_Index,
	prev:   Edge_Index,
}

Half_Edge_Mesh :: struct {
	vertices: []Vertex,
	faces:    []Face,
	edges:    []Half_Edge,
}

mesh_from_vertex_index_list :: proc(
	vertices: []Vec3,
	indices: []u16,
	vertices_per_face: int = 3,
	allocator := context.allocator,
) -> Half_Edge_Mesh {
	num_faces := len(indices) / vertices_per_face
	mesh: Half_Edge_Mesh
	verts := make([]Vertex, len(vertices), allocator)
	faces := make([]Face, num_faces, allocator)
	edges := make([]Half_Edge, len(indices), allocator)

	mesh.vertices = verts
	mesh.faces = faces
	mesh.edges = edges

	for pos, i in vertices {
		verts[i].pos = pos
		verts[i].edge = -1
	}

	temp_edges: map[[2]u16]Edge_Index = make_map(map[[2]u16]Edge_Index, context.temp_allocator)

	for f in 0 ..< num_faces {
		for i in 0..<vertices_per_face {
			e := f * vertices_per_face + i
			index := indices[e]

			if i == 0 {
				faces[f].edge = Edge_Index(e)
			}

			next_edge := f * vertices_per_face + ((i + 1) % vertices_per_face)
			prev_edge := f * vertices_per_face + ((i - 1) % vertices_per_face)

			edges[e] = {
				origin = Vertex_Index(index),
				twin = -1,
				face = Face_Index(f),
				next = Edge_Index(next_edge),
				prev = Edge_Index(prev_edge),
			}

			next_index := indices[next_edge]
			stable_idx := [2]u16{min(index, next_index), max(index, next_index)}
			twin, ok := temp_edges[stable_idx]

			if ok {
				edges[e].twin = twin
				edges[twin].twin = Edge_Index(e)
			} else {
				temp_edges[stable_idx] = Edge_Index(e)
			}
		}
	}

	return mesh
}