local _R = debug.getregistry()
_R.EllipseCache = {}

local VMatrix = _R.VMatrix
local VMatrix_SetUnpacked = VMatrix.SetUnpacked

local IMesh = _R.IMesh
local IMesh_Draw = IMesh.Draw
local IMesh_Destroy = IMesh.Destroy
local IMesh_IsValid = IMesh.IsValid
local IMesh_BuildFromTriangles = IMesh.BuildFromTriangles

local Ellipse do
	local ellipse_matrix = Matrix()

	local anchor_vertex = {
		pos = Vector(0, 0),
		u = 0.5, v = 0.5,
	}

	local function RenderEllipse(ellipse_mesh, scale_x, scale_y)
		return function(self, x, y, rotation)
			if not self:IsValid() then return false end

			x, y = tonumber(x) or 0, tonumber(y) or 0
			rotation = tonumber(rotation) or 0

			if rotation ~= 0 then
				local rotation = math.rad(rotation)
				local cos, sin = math.cos(rotation), math.sin(rotation)

				VMatrix_SetUnpacked(ellipse_matrix,
					cos * scale_x, -sin * scale_y, 0, x,
					sin * scale_x,  cos * scale_y, 0, y,
					0, 0, 1, 0,
					0, 0, 0, 1
				)
			else
				VMatrix_SetUnpacked(ellipse_matrix,
					scale_x, 0, 0, x,
					0, scale_y, 0, y,
					0, 0, 1, 0,
					0, 0, 0, 1
				)
			end

			cam.PushModelMatrix(ellipse_matrix)
				IMesh_Draw(ellipse_mesh)
			cam.PopModelMatrix()

			return true
		end
	end

	function Ellipse(width, height, start_angle, end_angle, distance, color)
		local width, height = width / 2, height / 2
		local radius = math.max(width, height)
		local start_angle, end_angle = math.Clamp(start_angle, 0, 360), math.Clamp(end_angle, 0, 360)

		local id = string.format("%i-%i-%i-%.2f-%s", radius, start_angle, end_angle, distance, color or color_white)

		if not _R.EllipseCache[id] then
			local vertices = {}
			local vertex_count = 0
			local step = distance / radius
			local start_angle, end_angle = math.rad(start_angle), math.rad(end_angle)

			for angle = start_angle, end_angle, step do
				local a, b = angle, angle + step
				b = math.min(b, end_angle)

				local a_cos, a_sin = math.cos(a), math.sin(a)
				local b_cos, b_sin = math.cos(b), math.sin(b)

				vertices[vertex_count + 1] = anchor_vertex

				vertices[vertex_count + 2] = {
					pos = Vector(a_cos * radius, a_sin * radius),
					u = 0.5 + a_cos / 2, v = 0.5 + a_sin / 2,
				}

				vertices[vertex_count + 3] = {
					pos = Vector(b_cos * radius, b_sin * radius),
					u = 0.5 + b_cos / 2, v = 0.5 + b_sin / 2,
				}

				vertex_count = vertex_count + 3
			end

			local ellipse_mesh = Mesh()
			IMesh_BuildFromTriangles(ellipse_mesh, vertices)

			_R.EllipseCache[id] = setmetatable(
				{
					Destroy = function()
						_R.EllipseCache[id] = nil
						return IMesh_Destroy(ellipse_mesh)
					end,

					IsValid = function()
						return IMesh_IsValid(ellipse_mesh)
					end,
				},

				{
					__call = RenderEllipse(ellipse_mesh, width / radius, height / radius),
				}
			)
		end

		return _R.EllipseCache[id]
	end
end

return Ellipse