## T-1182 tests: step_canvas_transport.gd — the D-255(a) six-rung stepped
## transport state machine (rung ladder, cursor-anchored step math,
## viewport-fit extent, world<->canvas-local projection). All pure
## functions, no scene tree needed.
class_name TestStepCanvasTransport
extends GdUnitTestSuite

const StepCanvasTransport := preload("res://ui/implant/apps/atlas/step_canvas/step_canvas_transport.gd")


# =============================================================================
# Rung ladder — index <-> name, scroll clamping
# =============================================================================


func test_rung_at_index_zero_is_global() -> void:
	assert_str(StepCanvasTransport.rung_at_index(0)).is_equal(StepCanvasTransport.RUNG_GLOBAL)


func test_rung_at_index_five_is_chunk_the_deepest() -> void:
	assert_str(StepCanvasTransport.rung_at_index(5)).is_equal(StepCanvasTransport.RUNG_CHUNK)


func test_rung_at_index_clamps_out_of_range_indices() -> void:
	assert_str(StepCanvasTransport.rung_at_index(-3)).is_equal(StepCanvasTransport.RUNG_GLOBAL)
	assert_str(StepCanvasTransport.rung_at_index(99)).is_equal(StepCanvasTransport.RUNG_CHUNK)


func test_index_for_rung_round_trips_every_ladder_entry() -> void:
	for i in range(StepCanvasTransport.RUNG_LADDER.size()):
		var rung: String = StepCanvasTransport.rung_at_index(i)
		assert_int(StepCanvasTransport.index_for_rung(rung)).is_equal(i)


func test_index_for_rung_unrecognized_returns_negative_one() -> void:
	assert_int(StepCanvasTransport.index_for_rung("Sector")).is_equal(-1)


func test_scroll_step_descends_one_notch_at_a_time() -> void:
	assert_int(StepCanvasTransport.scroll_step(0, 1)).is_equal(1)
	assert_int(StepCanvasTransport.scroll_step(2, 1)).is_equal(3)


func test_scroll_step_ascends_one_notch_at_a_time() -> void:
	assert_int(StepCanvasTransport.scroll_step(3, -1)).is_equal(2)


func test_scroll_step_clamps_at_the_deepest_rung() -> void:
	assert_int(StepCanvasTransport.scroll_step(5, 1)).is_equal(5)


func test_scroll_step_clamps_at_the_global_opener() -> void:
	assert_int(StepCanvasTransport.scroll_step(0, -1)).is_equal(0)


func test_scroll_step_zero_direction_is_a_no_op() -> void:
	assert_int(StepCanvasTransport.scroll_step(2, 0)).is_equal(2)


# =============================================================================
# D-243 gridunit spacing — pinned against the same metre values scale.rs uses
# =============================================================================


func test_spacing_for_rung_matches_d243_metre_values() -> void:
	assert_float(StepCanvasTransport.spacing_for_rung("Global")).is_equal_approx(204_800.0, 0.01)
	assert_float(StepCanvasTransport.spacing_for_rung("Region")).is_equal_approx(204_800.0, 0.01)
	assert_float(StepCanvasTransport.spacing_for_rung("District")).is_equal_approx(2_048.0, 0.01)
	assert_float(StepCanvasTransport.spacing_for_rung("Quarter")).is_equal_approx(512.0, 0.01)
	assert_float(StepCanvasTransport.spacing_for_rung("Block")).is_equal_approx(128.0, 0.01)
	assert_float(StepCanvasTransport.spacing_for_rung("Chunk")).is_equal_approx(64.0, 0.01)


# =============================================================================
# Display ratio — deep/mid 1x1, shallow ~5x5, PRESENTATION only (D-255(a))
# =============================================================================


func test_display_ratio_deep_rungs_are_one_to_one() -> void:
	for rung in ["District", "Quarter", "Block", "Chunk"]:
		assert_float(StepCanvasTransport.display_ratio_for_rung(rung)).is_equal_approx(1.0, 0.001)


func test_display_ratio_shallow_rungs_use_the_five_x_five_fallback() -> void:
	for rung in ["Global", "Region"]:
		assert_float(StepCanvasTransport.display_ratio_for_rung(rung)).is_equal_approx(5.0, 0.001)


func test_is_orbital_rung_true_only_for_global_and_region() -> void:
	assert_bool(StepCanvasTransport.is_orbital_rung("Global")).is_true()
	assert_bool(StepCanvasTransport.is_orbital_rung("Region")).is_true()
	assert_bool(StepCanvasTransport.is_orbital_rung("District")).is_false()
	assert_bool(StepCanvasTransport.is_orbital_rung("Chunk")).is_false()


# =============================================================================
# Viewport-fit extent — the client half of "viewport-sized canvas"
# =============================================================================


func test_viewport_fit_extent_at_deep_ratio_matches_viewport_pixels() -> void:
	# 1x1 ratio -> extent in gridunits == viewport px, 1:1.
	var extent: Vector2i = StepCanvasTransport.viewport_fit_extent(Vector2(800.0, 600.0), "Chunk")
	assert_that(extent).is_equal(Vector2i(800, 600))


func test_viewport_fit_extent_at_shallow_ratio_divides_by_the_display_ratio() -> void:
	var extent: Vector2i = StepCanvasTransport.viewport_fit_extent(Vector2(1000.0, 500.0), "Region")
	assert_that(extent).is_equal(Vector2i(200, 100))


func test_viewport_fit_extent_clamps_to_the_fixed_canvas_max_axis() -> void:
	var extent: Vector2i = StepCanvasTransport.viewport_fit_extent(
		Vector2(20_000.0, 20_000.0), "Chunk"
	)
	assert_int(extent.x).is_equal(StepCanvasTransport.FIXED_CANVAS_MAX_AXIS)
	assert_int(extent.y).is_equal(StepCanvasTransport.FIXED_CANVAS_MAX_AXIS)


func test_viewport_fit_extent_never_produces_a_zero_axis() -> void:
	var extent: Vector2i = StepCanvasTransport.viewport_fit_extent(Vector2(0.0, 0.0), "Chunk")
	assert_int(extent.x).is_greater_equal(1)
	assert_int(extent.y).is_greater_equal(1)


# =============================================================================
# Gridunit snapping — cache-key stability for repeated "same spot" requests
# =============================================================================


func test_snap_to_gridunit_snaps_to_the_rungs_own_spacing() -> void:
	var snapped: Vector2i = StepCanvasTransport.snap_to_gridunit(Vector2(2100.0, -1000.0), "District")
	# District spacing = 2048 m: 2100 rounds to 1*2048=2048, -1000 rounds to 0.
	assert_int(snapped.x).is_equal(2048)
	assert_int(snapped.y).is_equal(0)


func test_snap_to_gridunit_is_idempotent_once_already_on_grid() -> void:
	var once: Vector2i = StepCanvasTransport.snap_to_gridunit(Vector2(4096.0, 6144.0), "District")
	var world_again := Vector2(once.x, once.y)
	var twice: Vector2i = StepCanvasTransport.snap_to_gridunit(world_again, "District")
	assert_that(once).is_equal(twice)


# =============================================================================
# World <-> canvas-local projection — the shared transform both the terrain
# and annotation layers agree on by construction
# =============================================================================


func test_world_m_to_canvas_local_centers_the_world_center_on_the_canvas_center() -> void:
	var extent := Vector2i(64, 64)
	var rung := "District"
	var world_center := Vector2(10_000.0, 20_000.0)
	var local: Vector2 = StepCanvasTransport.world_m_to_canvas_local(
		world_center, world_center, rung, extent
	)
	var expected_center: Vector2 = StepCanvasTransport.canvas_footprint_px(rung, extent) * 0.5
	assert_that(local).is_equal_approx(expected_center, Vector2(0.01, 0.01))


## world_m_to_canvas_local() and canvas_local_to_world_m() must be exact
## inverses of one another — a round trip through both must recover the
## original world point (within float tolerance). This is the invariant the
## cursor-anchored scroll step depends on: whatever point the cursor reads
## as "under it" before a scroll must be the SAME point after re-deriving
## from the new step's own frame.
func test_world_to_local_and_back_round_trips() -> void:
	var extent := Vector2i(128, 96)
	var rung := "Quarter"
	var world_center := Vector2(50_000.0, -30_000.0)
	var original_world := Vector2(51_200.0, -29_500.0)

	var local: Vector2 = StepCanvasTransport.world_m_to_canvas_local(
		original_world, world_center, rung, extent
	)
	var recovered_world: Vector2 = StepCanvasTransport.canvas_local_to_world_m(
		local, world_center, rung, extent
	)
	assert_that(recovered_world).is_equal_approx(original_world, Vector2(0.5, 0.5))


func test_canvas_footprint_px_is_extent_times_display_ratio() -> void:
	var footprint: Vector2 = StepCanvasTransport.canvas_footprint_px("Region", Vector2i(100, 50))
	assert_that(footprint).is_equal(Vector2(500.0, 250.0))  # 5x5 shallow ratio


func test_half_extent_m_is_half_the_cell_count_times_spacing() -> void:
	var half: float = StepCanvasTransport.half_extent_m("District", 64)
	assert_float(half).is_equal_approx(64.0 * 0.5 * 2048.0, 0.01)