extends SceneTree
const FixtureCleanup := preload("res://tests/helpers/ui_audio_fixture_cleanup.gd")

# Exercise viewport GUI hit testing; do not emit button signals or call map handlers.
var checks := 0
var failures := 0
var main: Control
var runtime: Variant
var clock: Variant
func expect(ok: bool, message: String) -> void:
	checks += 1
	if not ok:
		failures += 1
		push_error(message)
func _initialize() -> void: call_deferred("run")
func click_at(point: Vector2) -> void:
	var motion := InputEventMouseMotion.new()
	motion.position = point
	motion.global_position = point
	root.push_input(motion, true)
	for pressed: bool in [true, false]:
		var event := InputEventMouseButton.new()
		event.position = point
		event.global_position = point
		event.button_index = MOUSE_BUTTON_LEFT
		event.pressed = pressed
		event.button_mask = MOUSE_BUTTON_MASK_LEFT if pressed else 0
		root.push_input(event, true)
		await process_frame
func run() -> void:
	runtime = root.get_node("SimulationRuntime")
	clock = root.get_node("GameClock")
	var state: Variant = root.get_node("GameState")
	clock.reset(1,6,0);state.reset();runtime.initialize(clock,state,42508);clock.set_paused(true)
	root.size = Vector2i(1440,810)
	main = load("res://scenes/main/main.tscn").instantiate()
	main.set("manual_save_path", "user://tests/build_pointer_%d" % Time.get_ticks_usec())
	root.add_child(main)
	runtime.configure_save_policy({&"enabled":false, &"daily_checkpoint_enabled":false})
	await process_frame;await process_frame
	await click_at((main.get("palette_toggle_button") as Button).get_global_rect().get_center())
	expect(main.get("palette_scroll").visible, "viewport click opens construction palette")
	for item: Dictionary in [
		{&"id": &"reception", &"cell": Vector3i(-6,0,0), &"cells":8},
		{&"id": &"premium_room", &"cell": Vector3i(-6,2,0), &"cells":4},
		{&"id": &"guest_stairs", &"cell": Vector3i(-7,1,0), &"cells":1},
		{&"id": &"guest_stairs", &"cell": Vector3i(-7,2,0), &"cells":1},
	]:
		var button: Button = main.get("build_buttons")[item[&"id"]]
		var scroll: ScrollContainer = main.get("palette_scroll")
		for attempt in 8:
			if scroll.get_global_rect().has_point(button.get_global_rect().get_center()): break
			var bar := scroll.get_h_scroll_bar()
			await click_at(bar.global_position + Vector2(bar.size.x-3,bar.size.y/2))
		# Clicking an already selected toggle would deselect the tool.
		if not button.button_pressed: await click_at(button.get_global_rect().get_center())
		expect(main.get("_selected_definition_id") == item[&"id"], "viewport click selects %s" % item[&"id"])
		var preview: WorldPreview = main.get("world_preview")
		var point := preview.global_position + preview.cell_to_canvas(item[&"cell"])
		expect(preview.get_global_rect().has_point(point), "placement target is visible")
		var before: int = runtime.construction_service.get_jobs().size()
		await click_at(point)
		expect(runtime.construction_service.get_jobs().size() == before+1, "viewport placement creates exactly one %s job" % item[&"id"])
		if runtime.construction_service.get_jobs().size() != before+1:
			print("Placement diagnostic: ", main.get("build_status_label").text)
			finish();return
		if item[&"id"] == &"premium_room":
			expect((main.find_child("InnOpeningGuide", true, false) as InnOpeningGuide).get_progress()[&"action"] == &"resume", "guide recognizes premium construction in progress")
		clock.advance_minutes(runtime.definition_registry.get_facility(item[&"id"]).build_minutes)
		var found := false
		for room: Dictionary in runtime.construction_service.get_facilities():
			if room[&"definition_id"] == item[&"id"] and room[&"origin"] == item[&"cell"]: found = room[&"occupied_cells"].size() == item[&"cells"]
		expect(found, "clicked construction completes with original geometry")
	expect((main.find_child("InnOpeningGuide", true, false) as InnOpeningGuide).get_progress()[&"stage"] == &"staff", "premium room advances opening guide to staff instead of requesting a standard room")
	await operate_day()
	if OS.get_environment("THE_TREE_POINTER_CAPTURE") == "1":
		await process_frame;await RenderingServer.frame_post_draw
		expect(root.get_texture().get_image().save_png(ProjectSettings.globalize_path("res://artifacts/facility-dimensions-2026-09-29/original-pointer.png")) == OK, "capture viewport-built room")
	finish()
func finish() -> void:
	SaveService.delete_save(main.get("manual_save_path"))
	var _audio_cleanup_final: Dictionary = await FixtureCleanup.free_owner_and_wait(self, main)
	if not bool(_audio_cleanup_final.get(&"passed", false)):
		push_error("Ordinary fixture audio cleanup failed: %s" % str(_audio_cleanup_final))
		quit(96)
		return
	print("Original build viewport input: %d checks, %d failures" % [checks,failures])
	quit(failures)

func press_key(code: Key, target: Window = root) -> void:
	for pressed: bool in [true,false]:
		var event := InputEventKey.new()
		event.keycode = code
		event.physical_keycode = code
		event.window_id = target.get_window_id()
		event.pressed = pressed
		Input.parse_input_event(event)
		await process_frame
func operate_day() -> void:
	await press_key(KEY_ESCAPE)
	await press_key(KEY_H)
	var hire: Button = main.get("staff_candidate_buttons")[&"staff_akane"]
	await click_at(hire.get_global_rect().get_center())
	var staff: Array = runtime.staff_service.get_staff_members()
	expect(staff.size() == 1, "pointer hires ordinary receptionist from candidates")
	if staff.is_empty(): return
	await click_at((main.get("staff_management_toggle_button") as Button).get_global_rect().get_center())
	var panel: StaffManagementPanel = main.get("staff_management_panel")
	await click_at((panel.roster_buttons[staff[0].staff_id] as Button).get_global_rect().get_center())
	var reception_id: StringName = &""
	var room_id: StringName = &""
	for room: FacilityInstance in runtime.facility_service.get_instances():
		if room.definition_id == &"reception": reception_id = room.instance_id
		if room.definition_id == &"premium_room": room_id = room.instance_id
	var option_index := -1
	for i in panel.facility_option.item_count:
		if StringName(panel.facility_option.get_item_metadata(i)) == reception_id: option_index = i
	expect(option_index >= 0, "reception appears in assignment options")
	if option_index < 0: return
	await click_at(panel.facility_option.get_global_rect().get_center())
	var popup := panel.facility_option.get_popup()
	await press_key(KEY_HOME, popup)
	for attempt in panel.facility_option.item_count + 1:
		if popup.get_focused_item() == option_index: break
		await press_key(KEY_DOWN, popup)
	await press_key(KEY_ENTER, popup)
	await click_at(panel.apply_button.get_global_rect().get_center())
	clock.advance_minutes(2)
	expect(runtime.staff_service.get_staff(staff[0].staff_id).assigned_facility_id == reception_id, "pointer/dropdown keyboard assigns receptionist")
	print("ASSIGNMENT_UI selected=",panel.facility_option.selected," expected=",option_index," result=",panel.result_label.text," popup=",popup.visible)
	if runtime.staff_service.get_staff(staff[0].staff_id).assigned_facility_id != reception_id: return
	await press_key(KEY_ESCAPE)
	expect(runtime.get_facility_access_report(room_id)[&"reachable"], "clicked stairs connect the premium room")
	while clock.absolute_minute < 1440:
		var before: int = clock.absolute_minute
		clock.advance_minutes(mini(30,1440-clock.absolute_minute))
		if clock.absolute_minute == before:
			expect(false, "ordinary clock did not advance: %s" % runtime.get_operations_report());return
		if clock.absolute_minute % 120 == 52: print("PREMIUM_DAY minute=",clock.absolute_minute)
		await process_frame
	var sales := 0
	for entry: LedgerEntry in runtime.economy_service.get_entries():
		if entry.category == &"SERVICE_SALE" and entry.source_entity_id == room_id: sales += entry.amount
	expect(sales > 0, "natural arrivals complete paid premium lodging before first midnight")
	expect(runtime.operations_coordinator.get_day_summaries().size() == 1 and runtime.economy_service.validate_ledger()[&"ok"], "natural premium day closes with balanced ledger")
	expect((main.find_child("InnOpeningGuide", true, false) as InnOpeningGuide).get_progress()[&"stage"] == &"complete", "premium revenue and midnight close complete the opening guide")
	print("PREMIUM_POINTER_DAY sales=", sales, " minute=", clock.absolute_minute)
	# Close the daily ledger before clicking the ordinary save control.
	await press_key(KEY_ESCAPE)
	for button: Node in main.find_children("*", "Button", true, false):
		if button.text == "保存":
			await click_at(button.get_global_rect().get_center())
			break
	var saved: Dictionary = SaveService.load_snapshot(main.get("manual_save_path"))
	expect(saved[&"ok"], "pointer saves normal premium-day progress")
	if saved[&"ok"]:
		clock.advance_minutes(2)
		await choose_original_manual_load(saved[&"snapshot"])
		expect(clock.absolute_minute == 1440, "load-menu input restores saved day boundary")
		expect((main.find_child("InnOpeningGuide", true, false) as InnOpeningGuide).get_progress()[&"stage"] == &"complete", "load preserves completed premium opening guidance")
		var loaded: Dictionary = runtime.create_snapshot()
		for section: StringName in [&"facilities", &"economy", &"guests", &"staff", &"construction"]:
			expect(loaded[&"systems"][&"runtime"][section] == saved[&"snapshot"][&"systems"][&"runtime"][section], "load-menu input restores %s state" % section)
		clock.advance_minutes(30)
		var continued: Dictionary = runtime.create_snapshot()
		expect(runtime.restore_snapshot(loaded), "loaded next-day state can be replayed")
		clock.advance_minutes(30)
		expect(runtime.create_snapshot() == continued, "loaded inn continues thirty minutes with deterministic guest/staff/economy replay")

# Standard headless GUI fixture: no claim of native OS Window focus or human input.
# IDs come from the actual Main menu; do not call/emit a load handler.
func choose_original_manual_load(saved_snapshot: Dictionary) -> void:
	var menu: MenuButton = main.find_child("SaveLoadMenu", true, false) as MenuButton
	var records: Array[Dictionary] = []
	var activated: Array[int] = []
	var completions: Array[Dictionary] = []
	var before: Dictionary = runtime.create_snapshot()
	if menu == null:
		expect(false, "actual original manual Load menu exists")
		store_original_menu_probe(records, activated, completions, saved_snapshot, before, runtime.create_snapshot())
		return
	var load_popup: PopupMenu = menu.get_popup()
	var on_id := func(id: int) -> void:
		activated.append(id)
		record_original_menu_probe(records, menu, load_popup, "passive_id_pressed", {"id": id})
	var on_completion := func(result: Dictionary) -> void:
		completions.append(result.duplicate(true))
		record_original_menu_probe(records, menu, load_popup, "passive_save_operation_completed", {"result": result.duplicate(true)})
	load_popup.id_pressed.connect(on_id)
	var completed_signal := Signal(runtime, &"save_operation_completed")
	completed_signal.connect(on_completion)
	record_original_menu_probe(records, menu, load_popup, "before_pointer")
	await click_original_menu(menu, records, load_popup)
	record_original_menu_probe(records, menu, load_popup, "after_full_pointer_release")
	# Preserve HOME; PopupMenu does not guarantee it selects its first item.
	await press_key(KEY_HOME,load_popup)
	record_original_menu_probe(records, menu, load_popup, "after_original_HOME")
	var inventory: Array[Dictionary] = []
	var id0_count := 0
	for index in load_popup.get_item_count():
		var item: Dictionary = {"index": index, "id": load_popup.get_item_id(index), "text": load_popup.get_item_text(index), "disabled": load_popup.is_item_disabled(index), "separator": load_popup.is_item_separator(index), "submenu": load_popup.get_item_submenu(index)}
		inventory.append(item)
		if item["id"] == 0 and not item["disabled"] and not item["separator"] and item["submenu"] == "": id0_count += 1
	var remaining: int = load_popup.get_item_count()
	var focused: int = load_popup.get_focused_item()
	while load_popup.visible and remaining > 0 and (focused < 0 or focused >= load_popup.get_item_count() or load_popup.get_item_id(focused) != 0):
		await press_key(KEY_DOWN,load_popup)
		remaining -= 1
		focused = load_popup.get_focused_item()
		record_original_menu_probe(records, menu, load_popup, "after_navigation_DOWN", {"remaining": remaining})
	var id0_focused: bool = load_popup.visible and id0_count == 1 and focused >= 0 and focused < load_popup.get_item_count() and load_popup.get_item_id(focused) == 0 and not load_popup.is_item_disabled(focused) and not load_popup.is_item_separator(focused) and load_popup.get_item_submenu(focused) == ""
	record_original_menu_probe(records, menu, load_popup, "before_original_ENTER", {"inventory": inventory, "id0_focused": id0_focused, "remaining": remaining, "activated": activated.duplicate()})
	expect(id0_focused, "actual original Popup focus reaches unique enabled manual-load ID0 before ENTER")
	if id0_focused:
		await press_key(KEY_ENTER,load_popup)
	record_original_menu_probe(records, menu, load_popup, "after_original_ENTER", {"activated": activated.duplicate(), "completions": completions.duplicate(true)})
	expect(activated.size() == 1 and activated[0] == 0, "actual original manual-load ID0 emits exactly once after full ENTER")
	load_popup.id_pressed.disconnect(on_id)
	completed_signal.disconnect(on_completion)
	store_original_menu_probe(records, activated, completions, saved_snapshot, before, runtime.create_snapshot())

func click_original_menu(menu: MenuButton, records: Array[Dictionary], popup: PopupMenu) -> void:
	var logical_point: Vector2 = menu.get_global_rect().get_center()
	var physical_point: Vector2 = root.get_final_transform() * logical_point
	var logical_ok: bool = menu.is_visible_in_tree() and menu.get_global_rect().has_point(logical_point) and root.get_visible_rect().has_point(logical_point)
	var physical_ok: bool = Rect2(Vector2.ZERO, Vector2(root.size)).has_point(physical_point)
	record_original_menu_probe(records, menu, popup, "actual_menu_geometry", {"logical_point": logical_point, "physical_point": physical_point, "control_rect": menu.get_global_rect(), "logical_root_rect": root.get_visible_rect(), "physical_root_rect": Rect2(Vector2.ZERO, Vector2(root.size)), "root_final_transform": root.get_final_transform(), "logical_ok": logical_ok, "physical_ok": physical_ok})
	expect(logical_ok and physical_ok, "actual original menu pointer lies inside logical target and physical Root")
	if not logical_ok or not physical_ok: return
	var motion := InputEventMouseMotion.new()
	motion.position = physical_point; motion.global_position = physical_point; motion.window_id = root.get_window_id()
	Input.parse_input_event(motion); Input.flush_buffered_events()
	record_original_menu_probe(records, menu, popup, "after_motion_parse_flush")
	for pressed: bool in [true, false]:
		var event := InputEventMouseButton.new()
		event.position = physical_point; event.global_position = physical_point; event.window_id = root.get_window_id()
		event.button_index = MOUSE_BUTTON_LEFT; event.pressed = pressed
		event.button_mask = MOUSE_BUTTON_MASK_LEFT if pressed else 0
		record_original_menu_probe(records, menu, popup, "before_button_parse_flush", {"pressed": pressed, "event_position": event.position, "event_window_id": event.window_id})
		Input.parse_input_event(event); Input.flush_buffered_events()
		record_original_menu_probe(records, menu, popup, "after_button_parse_flush", {"pressed": pressed})
		await process_frame
		record_original_menu_probe(records, menu, popup, "after_button_frame", {"pressed": pressed})

func record_original_menu_probe(records: Array[Dictionary], menu: MenuButton, popup: PopupMenu, label: String, extra: Dictionary = {}) -> void:
	var focused: int = popup.get_focused_item()
	var report: Dictionary = {"label": label, "pid": OS.get_process_id(), "ticks_usec": Time.get_ticks_usec(), "absolute_minute": clock.absolute_minute, "backend": DisplayServer.get_name(), "root_window_id": root.get_window_id(), "root_instance_id": root.get_instance_id(), "root_has_focus": root.has_focus(), "menu_instance_id": menu.get_instance_id(), "menu_path": String(menu.get_path()), "menu_disabled": menu.disabled, "menu_visible_in_tree": menu.is_visible_in_tree(), "popup_instance_id": popup.get_instance_id(), "popup_window_id": popup.get_window_id(), "popup_visible": popup.visible, "popup_item_count": popup.get_item_count(), "focused_index": focused, "focused_id": popup.get_item_id(focused) if focused >= 0 and focused < popup.get_item_count() else -1, "Input_mouse_button_mask": Input.get_mouse_button_mask(), "Input_left_pressed": Input.is_mouse_button_pressed(MOUSE_BUTTON_LEFT)}
	report.merge(extra)
	records.append(report)

func store_original_menu_probe(records: Array[Dictionary], activated: Array[int], completions: Array[Dictionary], saved_snapshot: Dictionary, before: Dictionary, after: Dictionary) -> void:
	var prefix: String = ProjectSettings.globalize_path(String(main.get("manual_save_path")) + "_menu_probe")
	var requested: String = OS.get_environment("THE_TREE_BUILD_POINTER_MENU_PROOF_FILE")
	var manifest_path: String = prefix.path_join("menu-proof.json")
	if not requested.is_empty():
		manifest_path = requested
		prefix = requested.get_base_dir()
	var error := DirAccess.make_dir_recursive_absolute(prefix)
	expect(error == OK, "fresh original menu observation directory can be created")
	if error != OK: return
	var nonce: String = OS.get_environment("THE_TREE_BUILD_POINTER_MENU_PROOF_NONCE")
	if nonce.is_empty(): nonce = String(main.get("manual_save_path")).get_file()
	var raw_files: Dictionary = {"saved-snapshot.varbytes": saved_snapshot, "before-menu-runtime.varbytes": before, "after-menu-runtime.varbytes": after, "menu-observations.varbytes": {"pid": OS.get_process_id(), "nonce": nonce, "manual_save_path": String(main.get("manual_save_path")), "observations": records, "activated_ids": activated, "save_operation_completed": completions, "Runtime_fields_added": 0, "normalization": false, "headless_viewport_scope": DisplayServer.get_name() == "headless", "human_OS_input": false}}
	var descriptors: Dictionary = {}
	for name: String in raw_files:
		var path: String = prefix.path_join(name)
		expect(not FileAccess.file_exists(path), "original menu observation file is fresh: %s" % name)
		if FileAccess.file_exists(path): continue
		var file := FileAccess.open(path, FileAccess.WRITE)
		expect(file != null, "original menu observation file can be opened: %s" % name)
		if file != null:
			var raw: PackedByteArray = var_to_bytes(raw_files[name])
			file.store_buffer(raw); file.close()
			var digest := HashingContext.new()
			digest.start(HashingContext.HASH_SHA256); digest.update(raw)
			descriptors[name] = {"path": path, "bytes": raw.size(), "sha256": digest.finish().hex_encode()}
	var source_bytes: PackedByteArray = FileAccess.get_file_as_bytes("res://tests/ui/test_original_build_pointer.gd")
	var source_digest := HashingContext.new()
	source_digest.start(HashingContext.HASH_SHA256); source_digest.update(source_bytes)
	var manifest: Dictionary = {"schema_version": 1, "pid": OS.get_process_id(), "nonce": nonce, "report_owner_source_sha256": source_digest.finish().hex_encode(), "raw_files": descriptors, "raw_file_count": descriptors.size(), "normalization": false, "Runtime_fields_added": 0, "headless_viewport_scope": DisplayServer.get_name() == "headless", "human_OS_input": false}
	expect(not FileAccess.file_exists(manifest_path), "original menu observation manifest is fresh")
	if FileAccess.file_exists(manifest_path): return
	var report_file := FileAccess.open(manifest_path, FileAccess.WRITE)
	expect(report_file != null, "original menu observation manifest can be opened")
	if report_file != null:
		var text: String = JSON.stringify(manifest)
		report_file.store_string(text); report_file.close()
		print("ORIGINAL_BUILD_MENU_PROOF " + text)