# Abstraction of a Polygon
abstract class APolygon
	# Vertices of this polygon
	var points: Array[Point[Float]]

	init do assert points.length >= 3

	# Get an array of the x coordinates of the vertices
	private fun x_coordinates: Array[Float] do
		return [for p in points do p.x]
	end

	# Get an array of the y coordinates of the vertices
	private fun y_coordinates: Array[Float] do
		return [for p in points do p.y]
	end

	# Get a matrice containing the coordinates of the vertices
	private fun vertices: Array[Array[Float]] do
		var vertices = new Array[Array[Float]]
		for i in [0..points.length[ do
			var temp = new Array[Float]
			temp.add(points[i].x)
			temp.add(points[i].y)
			vertices.add(temp)
		end
		return vertices
	end

	# Returns the axes corresponding to the edges of the polygon, used for collision detection
	private fun axes: Array[Point[Float]] do
		var axes = new Array[Point[Float]]
		for i in [0..points.length[ do
			var p1 = new Point[Float](points[i].x, points[i].y)
			var p2 = new Point[Float](points[(i+1) % points.length].x, points[(i+1) % points.length].y)
			var edge = new Point[Float](p1.x - p2.x, p1.y - p2.y)
			var normal = new Point[Float](-edge.y, edge.x)
			axes[i] = normal
		end
		return axes
	end

	# Sort the vertices in counter clockwise order
	#
	# ~~~
	# var p1 = new Point[Float](0.0, 0.0)
	# var p2 = new Point[Float](5.0, 0.0)
	# var p3 = new Point[Float](0.0, 5.0)
	# var p4 = new Point[Float](5.0, 5.0)
	# var arr = new Array[Point[Float]].with_items(p1, p2, p3, p4)
	# var poly = new ConvexPolygon(arr)
	# poly.sort_ccw
	# assert poly.points == [p4, p2, p1, p3]
	# ~~~
	fun sort_ccw do
		var sorter = new CounterClockWiseSort.with_center(vertices)
		sorter.sort(points)
	end

	# Sort the vertices in clockwise order
	#
	# ~~~
	# var p1 = new Point[Float](0.0, 0.0)
	# var p2 = new Point[Float](5.0, 0.0)
	# var p3 = new Point[Float](0.0, 5.0)
	# var p4 = new Point[Float](5.0, 5.0)
	# var arr = new Array[Point[Float]].with_items(p1, p2, p3, p4)
	# var poly = new ConvexPolygon(arr)
	# poly.sort_cw
	# assert poly.points == [p3, p1, p2, p4]
	# ~~~
	fun sort_cw do
		var sorter = new ClockWiseSort.with_center(vertices)
		sorter.sort(points)
	end

	# Is `self` convex ?
	#
	# ~~~
	# var p1 = new Point[Float](0.0, 0.0)
	# var p2 = new Point[Float](5.0, 0.0)
	# var p3 = new Point[Float](0.0, 5.0)
	# var p4 = new Point[Float](5.0, 5.0)
	# var arr = new Array[Point[Float]].with_items(p1, p2, p3, p4)
	# var poly = new ConvexPolygon(arr)
	# poly.sort_ccw
	# assert poly.is_convex
	# ~~~
	fun is_convex: Bool do
		var prev = points[points.length - 2]
		var curr = points[points.length - 1]
		var next = points[0]
		var is_ccw = turn_left(prev, curr, next)
		for i in [1..points.length[ do
			prev = curr
			curr= next
			next = points[i]
			if turn_left(prev ,curr, next) != is_ccw then return false
		end
		return true
	end

	# Generate a projection of an edge of the polygon on a given axis
	private fun project(axis: Point[Float]): Projection do
		var min = axis.x * points[0].x + axis.y * points[0].y
		var max = min
		for i in [0..points.length[ do
			var p = axis.x * points[i].x + axis.y * points[i].y
			if p < min then min = p
			if p > max then max = p
		end
		var projection = new Projection(min, max)
		return projection
	end

	# Remove  `p` from the vertices, keeping at least 3 vertices
	fun delete_vertex(p: Point[Float]) do
		assert points.length > 3
		points.remove(p)
	end

	# Does `self` intersects with `other`
	fun intersects(other: APolygon): Bool is abstract

	# Is `p` contained in `self` ?
	fun contain(p: Point[Float]): Bool is abstract

	# Add a vertex to `self`
	fun add_vertex(p: Point[Float]): Bool do
		points.add(p)
		return true
	end
end