# Phase 9 Prop Editor - headless regression checks for PropCanvas math
# (vertex insert/remove, mirror, z-order, clipboard, transforms, sanitize).
# No GUI event injection; the public math APIs are driven directly.
# Run with:
# & "C:\Godot4\Godot_v4.7.1-stable_win64_console.exe" --headless --path "C:\tmp\stickman" --script "res://tests/test_prop_editor_canvas.gd"

extends SceneTree

const PROP_CANVAS := preload("res://scripts/prop_canvas.gd")

var _checks: int = 0
var _failures: int = 0
var _changed_count: int = 0


func _initialize() -> void:
	call_deferred("_run")


func _run() -> void:
	print("\n=== PHASE 9 PROP CANVAS TEST ===")
	await _test_primitives()
	await _test_vertex_insert_remove()
	await _test_mirror()
	await _test_z_order()
	await _test_clipboard()
	await _test_transforms()
	await _test_sanitize_and_radius()
	await _test_import_export_and_clear()
	await _test_edit_mode()
	await _test_gizmo_constants()
	await _test_create_point_on_edge()
	await _test_segment_hit_test()
	await _test_reshaped_flag()
	await _test_selection_halo()
	print("----------------------------------------")
	if _failures == 0:
		print("RESULT: ALL PASSED (%d assertions)" % _checks)
		quit(0)
	else:
		print("RESULT: %d FAILURE(S) out of %d assertions" % [_failures, _checks])
		quit(1)


func check(label: String, condition: bool) -> void:
	_checks += 1
	if condition:
		print("PASS: %s" % label)
	else:
		_failures += 1
		print("FAIL: %s" % label)


func _new_canvas() -> PropCanvas:
	var canvas: PropCanvas = PROP_CANVAS.new()
	root.add_child(canvas)
	canvas.size = Vector2(800, 600)
	_changed_count = 0
	canvas.shape_changed.connect(func(_shapes: Array[Dictionary]) -> void: _changed_count += 1)
	return canvas


func _free_canvas(canvas: PropCanvas) -> void:
	canvas.queue_free()
	await process_frame


func _bbox(pts: Array) -> Rect2:
	var first: Dictionary = pts[0]
	var bbox := Rect2(Vector2(float(first.get("x", 0.0)), float(first.get("y", 0.0))), Vector2.ZERO)
	for p: Dictionary in pts:
		bbox = bbox.expand(Vector2(float(p.get("x", 0.0)), float(p.get("y", 0.0))))
	return bbox


func _export_points(sd: Dictionary) -> Array:
	return sd.get("points", []) as Array


func _test_primitives() -> void:
	var canvas: PropCanvas = _new_canvas()
	var box: Dictionary = canvas.add_primitive("box", Vector2(100, 100))
	check("box appended", canvas.shapes.size() == 1)
	check("box type", str(box.get("shape_type", "")) == "polygon")
	check("box 4 points", _export_points(box).size() == 4)
	check("box closed", bool(box.get("closed", false)))
	check("add emits shape_changed", _changed_count == 1)
	check("box selected", canvas.get_selected_index() == 0)

	var big: Dictionary = canvas.add_primitive("box", Vector2(200, 200), {"size_x": 100.0, "size_y": 100.0})
	var big_bbox: Rect2 = _bbox(_export_points(big))
	check("box params respected", is_equal_approx(big_bbox.size.x, 100.0) and is_equal_approx(big_bbox.size.y, 100.0))

	var ball: Dictionary = canvas.add_primitive("ball", Vector2(300, 300))
	check("ball type", str(ball.get("shape_type", "")) == "circle")
	check("ball radius default", is_equal_approx(float(ball.get("radius", 0.0)), 24.0))
	check("ball points 12", _export_points(ball).size() == 12)

	var line: Dictionary = canvas.add_primitive("line", Vector2(400, 400))
	check("line type", str(line.get("shape_type", "")) == "line")
	check("line open", not bool(line.get("closed", true)))
	check("line 2 points", _export_points(line).size() == 2)

	var plank: Dictionary = canvas.add_primitive("plank", Vector2(500, 500))
	check("plank polygon", str(plank.get("shape_type", "")) == "polygon")
	var triangle: Dictionary = canvas.add_primitive("triangle", Vector2(600, 600))
	check("triangle 3 points", _export_points(triangle).size() == 3)
	check("triangle closed", bool(triangle.get("closed", false)))
	var circle: Dictionary = canvas.add_primitive("circle", Vector2(700, 700), {"radius": 50.0})
	check("circle radius param", is_equal_approx(float(circle.get("radius", 0.0)), 50.0))
	await _free_canvas(canvas)


func _test_vertex_insert_remove() -> void:
	var canvas: PropCanvas = _new_canvas()
	canvas.add_primitive("box", Vector2(100, 100))
	canvas.insert_vertex(0, 2, Vector2(124, 100))
	check("insert grows point list", _export_points(canvas.get_shape_data()[0]).size() == 5)
	var flags: Array = canvas.get_shape_data()[0].get("vertex_flags", []) as Array
	check("inserted vertex flagged USER_CREATED", int(flags[2]) == 1)
	check("original vertices stay 0", int(flags[0]) == 0 and int(flags[4]) == 0)
	canvas.remove_vertex(0, 2)
	check("remove shrinks point list", _export_points(canvas.get_shape_data()[0]).size() == 4)
	check("flags aligned after remove", (canvas.get_shape_data()[0].get("vertex_flags", []) as Array).size() == 4)

	canvas.remove_vertex(0, 0)
	canvas.remove_vertex(0, 0)
	check("polygon with 2 points becomes open", bool(canvas.shapes[0].get("closed", true)) == false)
	canvas.remove_vertex(0, 0)
	check("below 2 vertices drops shape", canvas.shapes.size() == 0)
	check("selection cleared after drop", canvas.get_selected_index() == -1)
	await _free_canvas(canvas)


func _test_mirror() -> void:
	var canvas: PropCanvas = _new_canvas()
	var tri: Dictionary = canvas.add_primitive("triangle", Vector2(100, 100))
	var before: Array = _export_points(tri)
	var bbox: Rect2 = _bbox(before)
	canvas.mirror_x(0)
	var after_x: Array = _export_points(canvas.get_shape_data()[0])
	check("mirror_x flips x about center", is_equal_approx(float(after_x[0].get("x", 0.0)), 2.0 * bbox.get_center().x - float(before[0].get("x", 0.0))))
	check("mirror_x keeps y", is_equal_approx(float(after_x[0].get("y", 0.0)), float(before[0].get("y", 0.0))))
	check("mirror_x keeps bbox center", _bbox(after_x).get_center().is_equal_approx(bbox.get_center()))
	canvas.mirror_y(0)
	var after_y: Array = _export_points(canvas.get_shape_data()[0])
	check("mirror_y flips y about center", is_equal_approx(float(after_y[0].get("y", 0.0)), 2.0 * bbox.get_center().y - float(after_x[0].get("y", 0.0))))
	check("mirror_y keeps bbox center", _bbox(after_y).get_center().is_equal_approx(bbox.get_center()))
	await _free_canvas(canvas)


func _test_z_order() -> void:
	var canvas: PropCanvas = _new_canvas()
	canvas.add_primitive("box", Vector2(0, 0), {"fill_color": "#FF0000", "outline_color": "#000000"})
	canvas.add_primitive("ball", Vector2(100, 0), {"fill_color": "#00FF00", "outline_color": "#000000"})
	canvas.add_primitive("line", Vector2(200, 0), {"fill_color": "#0000FF", "outline_color": "#000000"})
	canvas.bring_forward(1)
	check("bring_forward swaps up", str(canvas.get_shape_data()[1].get("shape_type", "")) == "line")
	check("bring_forward swaps down", str(canvas.get_shape_data()[2].get("shape_type", "")) == "circle")
	canvas.send_back(2)
	check("send_back swaps down", str(canvas.get_shape_data()[1].get("shape_type", "")) == "circle")
	canvas.bring_forward(2)
	check("bring_forward at top is no-op", str(canvas.get_shape_data()[2].get("shape_type", "")) == "line")
	canvas.send_back(0)
	check("send_back at bottom is no-op", str(canvas.get_shape_data()[0].get("shape_type", "")) == "polygon")
	await _free_canvas(canvas)


func _test_clipboard() -> void:
	var canvas: PropCanvas = _new_canvas()
	canvas.add_primitive("box", Vector2(50, 50), {"fill_color": "#123456", "outline_color": "#000000"})
	var copied: Dictionary = canvas.copy_shape(0)
	check("copy returns deep dict", not copied.is_empty() and copied.has("points"))
	canvas.set_shape_fill_color(0, "#ABCDEF")
	check("copy is independent", str(copied.get("fill_color", "")) == "#123456")
	canvas.paste_shape(copied, Vector2(100, 100))
	check("paste appends", canvas.shapes.size() == 2)
	var pasted_pts: Array = _export_points(canvas.get_shape_data()[1])
	var pasted_bbox: Rect2 = _bbox(pasted_pts)
	check("paste offsets by (16,16)", pasted_bbox.get_center().is_equal_approx(Vector2(116, 116)))
	check("paste preserves color", str(canvas.get_shape_data()[1].get("fill_color", "")) == "#123456")
	check("paste selects new shape", canvas.get_selected_index() == 1)
	await _free_canvas(canvas)


func _test_transforms() -> void:
	var canvas: PropCanvas = _new_canvas()
	canvas.add_primitive("box", Vector2(100, 100))
	canvas.translate_selected(Vector2(10, -5))
	var pts: Array = _export_points(canvas.get_shape_data()[0])
	check("translate moves all vertices", _bbox(pts).get_center().is_equal_approx(Vector2(110, 95)))

	canvas.add_primitive("box", Vector2(200, 200))
	canvas.select(1)
	canvas.rotate_selected(PI / 2.0)
	var rotated_pts: Array = _export_points(canvas.get_shape_data()[1])
	# Box corners at (224,224) rotate 90 degrees ccw about (200,200) -> (176,224).
	var found: bool = false
	for p: Dictionary in rotated_pts:
		if Vector2(float(p.get("x", 0.0)), float(p.get("y", 0.0))).is_equal_approx(Vector2(176, 224)):
			found = true
	check("rotate 90 degrees about bbox center", found)
	check("rotate keeps bbox center", _bbox(rotated_pts).get_center().is_equal_approx(Vector2(200, 200)))

	canvas.scale_selected(Vector2(2.0, 1.0))
	var scaled_pts: Array = _export_points(canvas.get_shape_data()[1])
	var scaled_bbox: Rect2 = _bbox(scaled_pts)
	check("scale stretches width", is_equal_approx(scaled_bbox.size.x, 96.0))
	check("scale keeps height", is_equal_approx(scaled_bbox.size.y, 48.0))
	await _free_canvas(canvas)


func _test_sanitize_and_radius() -> void:
	var canvas: PropCanvas = _new_canvas()
	canvas.set_grid_size(16)
	canvas.set_snap_enabled(true)
	# Rectangle with one collinear point and one off-grid point; sanitize must
	# grid-snap, drop the collinear vertex, and enforce clockwise winding.
	canvas.set_shape_data([{
		"shape_type": "polygon",
		"points": [
			{"x": 0.0, "y": 0.0},
			{"x": 16.0, "y": 0.0},
			{"x": 32.0, "y": 0.0},
			{"x": 32.0, "y": 32.0},
			{"x": 0.0, "y": 33.0},
		],
		"fill_color": "#000000",
		"outline_color": "#000000",
		"outline_width": 2.0,
		"closed": true,
		"vertex_flags": [0, 1, 0, 0, 0],
	}])
	canvas.sanitize_shape(0)
	var pts: Array = _export_points(canvas.get_shape_data()[0])
	check("sanitize drops collinear vertex", pts.size() == 4)
	var packed := PackedVector2Array()
	for p: Dictionary in pts:
		packed.append(Vector2(float(p.get("x", 0.0)), float(p.get("y", 0.0))))
	check("sanitize enforces clockwise", Geometry2D.is_polygon_clockwise(packed))
	var min_y: float = INF
	var max_y: float = -INF
	for v: Vector2 in packed:
		min_y = minf(min_y, v.y)
		max_y = maxf(max_y, v.y)
	check("sanitize grid-snaps", is_equal_approx(min_y, 0.0) and is_equal_approx(max_y, 32.0))
	var flags: Array = canvas.get_shape_data()[0].get("vertex_flags", []) as Array
	check("sanitize keeps flags aligned", flags.size() == 4)

	var circle: Dictionary = canvas.add_primitive("circle", Vector2(300, 300), {"radius": 40.0})
	var before_count: int = _export_points(circle).size()
	canvas.sanitize_shape(1)
	check("sanitize skips circles", _export_points(canvas.get_shape_data()[1]).size() == before_count)
	canvas.set_shape_radius(1, 80.0)
	var radius_pts: Array = _export_points(canvas.get_shape_data()[1])
	check("set_shape_radius resizes points", is_equal_approx(float(canvas.get_shape_data()[1].get("radius", 0.0)), 80.0))
	var radius_bbox: Rect2 = _bbox(radius_pts)
	check("radius bbox matches", is_equal_approx(radius_bbox.size.x, 160.0) and is_equal_approx(radius_bbox.size.y, 160.0))
	await _free_canvas(canvas)


func _test_import_export_and_clear() -> void:
	var canvas: PropCanvas = _new_canvas()
	canvas.set_shape_data([{
		"shape_type": "polygon",
		"points": [{"x": 0.0, "y": 0.0}, {"x": 10.0, "y": 0.0}, {"x": 10.0, "y": 10.0}],
		"fill_color": "#111111",
		"outline_color": "#222222",
		"outline_width": 2.0,
		"closed": true,
		"vertex_flags": [0, 1, 0],
	}])
	check("import plain {x,y} data", canvas.shapes.size() == 1)
	check("import preserves flags", (canvas.shapes[0].get("vertex_flags", PackedInt32Array()) as PackedInt32Array).size() == 3)
	var exported: Array[Dictionary] = canvas.get_shape_data()
	check("export plain format", exported.size() == 1 and (exported[0].get("points", []) as Array)[0] is Dictionary)
	var before_changed: int = _changed_count
	canvas.clear()
	check("clear empties shapes", canvas.shapes.is_empty())
	check("clear emits no shape_changed", _changed_count == before_changed)
	check("export after clear empty", canvas.get_shape_data().is_empty())
	await _free_canvas(canvas)


func _test_edit_mode() -> void:
	var canvas: PropCanvas = _new_canvas()
	check("default mode is TRANSFORM", canvas.get_edit_mode() == PROP_CANVAS.EditMode.TRANSFORM)
	var mode_fires: Array = [0]
	canvas.mode_changed.connect(func(_mode: int) -> void: mode_fires[0] += 1)
	canvas.set_edit_mode(PROP_CANVAS.EditMode.POINTS)
	check("set_edit_mode(POINTS) applies", canvas.get_edit_mode() == PROP_CANVAS.EditMode.POINTS)
	check("mode_changed fired once on change", int(mode_fires[0]) == 1)
	canvas.set_edit_mode(PROP_CANVAS.EditMode.POINTS)
	check("re-setting same mode does not fire", int(mode_fires[0]) == 1)
	canvas.set_edit_mode(99)
	check("unknown mode clamps to TRANSFORM", canvas.get_edit_mode() == PROP_CANVAS.EditMode.TRANSFORM)
	check("clamp fires mode_changed", int(mode_fires[0]) == 2)
	canvas.set_edit_mode(PROP_CANVAS.EditMode.POINTS)
	canvas.add_primitive("box", Vector2(100, 100))
	canvas.clear()
	check("clear keeps the mode", canvas.get_edit_mode() == PROP_CANVAS.EditMode.POINTS)
	canvas.set_shape_data([])
	check("set_shape_data keeps the mode", canvas.get_edit_mode() == PROP_CANVAS.EditMode.POINTS)
	canvas.select(0)
	canvas.deselect()
	check("select/deselect keep the mode", canvas.get_edit_mode() == PROP_CANVAS.EditMode.POINTS)
	await _free_canvas(canvas)


func _test_gizmo_constants() -> void:
	check("rotation dot radius constant", is_equal_approx(PROP_CANVAS.ROTATION_CIRCLE_RADIUS, 5.0))
	check("rotation dot hit radius constant", is_equal_approx(PROP_CANVAS.ROTATION_CIRCLE_HIT_RADIUS, 12.0))
	check("rotation dot offset constant", is_equal_approx(PROP_CANVAS.ROTATION_CIRCLE_OFFSET, 26.0))
	check("scale cross size constant", is_equal_approx(PROP_CANVAS.SCALE_CROSS_SIZE, 5.0))
	check("scale cross hit radius constant", is_equal_approx(PROP_CANVAS.SCALE_CROSS_HIT_RADIUS, 12.0))
	check("vertex handle radius constant", is_equal_approx(PROP_CANVAS.HANDLE_RADIUS, 3.0))
	var constant_map: Dictionary = (PROP_CANVAS as Script).get_script_constant_map()
	check("rotate ring constant removed", not constant_map.has("ROTATE_RING_RADIUS"))
	check("scale circle constant removed", not constant_map.has("SCALE_HANDLE_DISTANCE"))


func _test_create_point_on_edge() -> void:
	var canvas: PropCanvas = _new_canvas()
	canvas.add_primitive("box", Vector2(100, 100))
	var created: Array = []
	canvas.vertex_created.connect(func(s_idx: int, v_idx: int) -> void: created.append([s_idx, v_idx]))
	# Cursor at (110, 60): the nearest segment is the top edge (76,76)-(124,76);
	# the projection onto it is (110, 76) - NOT the edge midpoint (100, 76).
	var idx: int = canvas.create_point_on_edge(Vector2(110, 60))
	check("create_point_on_edge returns valid index", idx >= 0)
	var pts: Array = _export_points(canvas.get_shape_data()[0])
	check("create point grows the vertex list", pts.size() == 5)
	var inserted: Dictionary = pts[idx]
	check("inserted point is the cursor projection", Vector2(float(inserted.get("x", 0.0)), float(inserted.get("y", 0.0))).is_equal_approx(Vector2(110, 76)))
	var flags: Array = canvas.get_shape_data()[0].get("vertex_flags", []) as Array
	check("inserted vertex flagged USER_CREATED", int(flags[idx]) == 1)
	check("vertex_created emitted with shape and vertex index", created.size() == 1 and int(created[0][0]) == 0 and int(created[0][1]) == idx)
	await _free_canvas(canvas)


func _test_segment_hit_test() -> void:
	var canvas: PropCanvas = _new_canvas()
	canvas.add_primitive("box", Vector2(100, 100))
	check("segment hit above top edge", canvas.hit_test_segment(Vector2(110, 70)) == 0)
	check("segment hit left of left edge", canvas.hit_test_segment(Vector2(70, 90)) == 0)
	check("segment hit misses interior", canvas.hit_test_segment(Vector2(100, 100)) == -1)
	check("segment hit misses empty canvas", canvas.hit_test_segment(Vector2(400, 400)) == -1)
	canvas.add_primitive("line", Vector2(300, 300))
	check("segment hit on open line", canvas.hit_test_segment(Vector2(300, 306)) == 1)
	canvas.select(1)
	check("segment hit frontmost wins", canvas.hit_test_segment(Vector2(300, 306)) == 1)
	await _free_canvas(canvas)


func _test_reshaped_flag() -> void:
	var canvas: PropCanvas = _new_canvas()
	canvas.add_primitive("circle", Vector2(100, 100), {"radius": 40.0})
	check("new circle not reshaped", not bool(canvas.shapes[0].get("reshaped", true)))
	check("export carries reshaped false", not bool(canvas.get_shape_data()[0].get("reshaped", true)))
	canvas.insert_vertex(0, 0, Vector2(60, 60))
	check("insert vertex reshapes", bool(canvas.shapes[0].get("reshaped", false)))
	canvas.set_shape_radius(0, 60.0)
	check("set_shape_radius clears reshaped", not bool(canvas.shapes[0].get("reshaped", true)))
	canvas.remove_vertex(0, 0)
	check("remove vertex reshapes", bool(canvas.shapes[0].get("reshaped", false)))
	canvas.add_primitive("circle", Vector2(300, 300), {"radius": 40.0})
	canvas.select(1)
	canvas.scale_selected(Vector2(2.0, 2.0))
	check("uniform scale keeps circle primitive", not bool(canvas.shapes[1].get("reshaped", true)))
	canvas.scale_selected(Vector2(2.0, 1.0))
	check("non-uniform scale reshapes circle", bool(canvas.shapes[1].get("reshaped", false)))
	canvas.add_primitive("box", Vector2(500, 500))
	canvas.select(2)
	canvas.translate_selected(Vector2(10, 0))
	check("translate does not reshape", not bool(canvas.shapes[2].get("reshaped", true)))
	canvas.rotate_selected(0.5)
	check("rotate does not reshape", not bool(canvas.shapes[2].get("reshaped", true)))
	canvas.mirror_x(2)
	check("mirror does not reshape", not bool(canvas.shapes[2].get("reshaped", true)))
	canvas.insert_vertex(2, 0, Vector2(400, 400))
	check("vertex insert reshapes polygon", bool(canvas.shapes[2].get("reshaped", false)))
	await _free_canvas(canvas)


func _test_selection_halo() -> void:
	check("selection halo is dark", PROP_CANVAS.SELECTION_HALO_COLOR.get_luminance() < 0.3)
	check("selection core is bright", PROP_CANVAS.SELECTION_CORE_COLOR.get_luminance() > 0.7)