extends "res://tests/fixtures/p23-03/observation.gd"
## Passive endpoint implementation. All gameplay/input is performed by Root CUA.
## Shared parent contains the handler endpoints, but every such endpoint below
## is overridden; this class never emits UI signals or invokes product handlers.
var receipts: Array = []
var terminated := false
var terminal_record: Dictionary = {}
var terminal_cause_recorded := false
var reveal_rows: Array = []
var all_requests: Array = []
var input_observer: Node
var last_dispatch: Dictionary = {}
var observed_categories: Dictionary = {}

func observe_progress() -> void:
	if role != "writer" or terminated: return
	var wanted: Dictionary = {}
	var report: Dictionary = main.world_preview.get_life_observation_report()
	for room: Dictionary in report.get(&"rooms", {}).values():
		if int(room.get(&"count", 0)) > 0: wanted["room-users"] = true
	for badge: Dictionary in report.get(&"landing_badges", []):
		if int(badge.get(&"overflow", 0)) > 0: wanted["queue-overflow"] = true
	for cabin: Dictionary in report.get(&"cabins", []):
		if not cabin[&"passengers"].is_empty(): wanted["EV-passengers"] = true
	var elevators: Dictionary = runtime.elevators.get_report()
	for shaft: Dictionary in elevators.get(&"shafts", []):
		if not shaft.get(&"boarded", []).is_empty(): wanted["EV-passengers"] = true
	for trip: Dictionary in elevators.get(&"trips", []):
		if trip.get(&"state", &"") == &"QUEUED": wanted["queue-present"] = true
	for member: StaffRuntime in runtime.staff_service.get_staff_members():
		if not member.carried_inventory_id.is_empty(): wanted["carried-goods"] = true
	if not report.get(&"resting_staff", {}).is_empty(): wanted["rest-position"] = true
	for category: String in wanted:
		if observed_categories.has(category): continue
		observed_categories[category] = true
		await layer_observations("actual-" + category)
		if category == "EV-passengers": await motion_observations()

func motion_observations() -> void:
	await button(main.front_button)
	await button(main.pause_button)
	expect(not clock.paused, "ordinary resume for motion observation")
	var minute: int = clock.absolute_minute
	while clock.absolute_minute == minute and not terminated:
		await tree.process_frame
	await frames()
	expect(await stream.await_draws(tree, main.world_preview), "real draw history before capture")
	expect(stream.capture("active-motion", runtime, main.world_preview), "active interpolation history")
	await button(main.pause_button)
	expect(clock.paused, "ordinary pause for stable observation")
	await frames()
	expect(await stream.await_draws(tree, main.world_preview), "real draw history before capture")
	expect(stream.capture("paused-motion", runtime, main.world_preview), "paused interpolation history")

class InputObserver extends Node:
	var events: Array = []
	var endpoint: RefCounted = null
	func _input(event: InputEvent) -> void:
		if event is InputEventMouseButton or event is InputEventKey or event is InputEventMouseMotion:
			var row := {"ticks_usec": Time.get_ticks_usec(), "text": event.as_text(), "pressed": event.is_pressed()}
			if event is InputEventMouseButton:
				row["button"] = event.button_index
				row["position"] = [event.position.x, event.position.y]
				row["ctrl"] = event.ctrl_pressed
				if endpoint != null and event.pressed and event.button_index == MOUSE_BUTTON_LEFT:
					row["dispatch"] = endpoint.dispatch_position(event.position)
			events.append(row)

func expect(ok: bool, message: String) -> void:
	if terminated and ok:
		return
	if terminated and terminal_cause_recorded:
		if not ok:
			terminal_record["suppressed_after_terminal"] += 1
			json_file(role + "-terminal.json", terminal_record)
		return
	if terminated and not ok:
		terminal_cause_recorded = true
	super.expect(ok, message)

func terminate(stem: String, reason: String) -> void:
	terminated = true
	terminal_record = {"pid": OS.get_process_id(), "role": role, "sequence": serial,
		"stem": stem, "reason": reason, "suppressed_after_terminal": 0}
	json_file(role + "-terminal.json", terminal_record)
	expect(false, reason)
	tree.quit(1)

func request(action: Dictionary) -> void:
	if terminated:
		return
	serial += 1
	var stem := "%s-request-%04d" % [role, serial]
	var folder := directory.path_join(stem)
	DirAccess.make_dir_recursive_absolute(folder)
	var window: Window = main.get_window()
	var view: WorldPreview = main.world_preview
	expect(await stream.await_draws(tree, view), "real draw history before capture")
	action["report"] = Codec.new().typed(view.get_life_observation_report())
	action["viewport_to_screen"] = affine(view.get_screen_transform() * view.get_global_transform_with_canvas().affine_inverse())
	action["local_to_viewport"] = affine(view.get_global_transform_with_canvas())
	action["local_to_screen"] = affine(view.get_screen_transform())
	action["rectangles"] = Codec.new().typed(draw_rectangles(view.get_life_observation_report(), view))
	action["requested_ticks_usec"] = Time.get_ticks_usec()
	action["requested_unix_ns"] = int(Time.get_unix_time_from_system() * 1000000000.0)
	action["screenshot_receipt_schema"] = {"screenshots": [{"path": "evidence-root-relative raw image path", "raw_sha256": "original byte SHA256", "tool_call_id": "actual CUA screenshot call ID"}]}
	expect(stream.capture(stem, runtime, view), "request state/report")
	action.merge({"sequence": serial, "target_pid": OS.get_process_id(), "role": role,
		"state": "waiting_for_root_cua", "window_title": window.title,
		"window_position": [window.position.x, window.position.y],
		"window_size": [window.size.x, window.size.y], "screen_scale": DisplayServer.screen_get_scale(window.current_screen),
		"content_scale_factor": window.content_scale_factor, "setup": "diagnostic"})
	json_file(stem + "/request.json", action)
	var path := folder.path_join("ack.json")
	var first_event: int = input_observer.events.size()
	var deadline := Time.get_ticks_msec() + 300000
	print("P23_ROOT_CUA_WAIT " + folder.path_join("request.json"))
	while not FileAccess.file_exists(path) and Time.get_ticks_msec() < deadline:
		await tree.process_frame
	if not FileAccess.file_exists(path):
		terminate(stem, "Root CUA acknowledgement timeout")
		return
	var ack: Variant = JSON.parse_string(FileAccess.get_file_as_string(path))
	if not ack is Dictionary or ack.get("target_pid") != OS.get_process_id() or ack.get("sequence") != serial or ack.get("request_sha256") != FileAccess.get_sha256(folder.path_join("request.json")):
		terminate(stem, "Root CUA acknowledgement identity/hash")
		return
	await frames()
	for event: Dictionary in input_observer.events.slice(first_event):
		if event.has("dispatch"):
			last_dispatch = event["dispatch"]
	json_file(stem + "/observed.json", {"pid": OS.get_process_id(), "sequence": serial,
		"ack_observed_ticks_usec": Time.get_ticks_usec(), "request_sha256": FileAccess.get_sha256(folder.path_join("request.json")),
		"ack_observed_unix_ns": int(Time.get_unix_time_from_system() * 1000000000.0),
		"observer_endpoint": "null_modal_receipts_only" if input_observer.endpoint == null else "passive_read_only_dispatch",
		"events": input_observer.events.slice(first_event), "status": main.build_status_label.text})
	receipts.append("os-pair/" + layout + "/" + stem + "/ack.json")
	all_requests.append("os-pair/" + layout + "/" + stem + "/ack.json")

func annotate(row: Dictionary) -> void:
	var view: WorldPreview = main.world_preview
	row["rectangles"] = Codec.new().typed(draw_rectangles(view.get_life_observation_report(), view))
	row["viewport_to_screen"] = affine(view.get_screen_transform() * view.get_global_transform_with_canvas().affine_inverse())
	row["reveal"] = reveal_rows.duplicate(true)
	reveal_rows.clear()
	row["input_method"] = "native_os"
	row["requests"] = receipts.duplicate()
	receipts.clear()

# Rectangles describe existing draw commands; no second renderer is invoked.
func draw_rectangles(report: Dictionary, view: WorldPreview) -> Dictionary:
	var rows: Array = []
	for id: Variant in report.get(&"rooms", {}):
		var room: Dictionary = report[&"rooms"][id]
		if room.has(&"rect"):
			rows.append({"category": "room", "id": id, "rect": room[&"rect"], "style_source": "scripts/ui/pixel_tower_art.gd"})
	for index: int in range(report.get(&"landing_badges", []).size()):
		var badge: Dictionary = report[&"landing_badges"][index]
		rows.append(badge_rectangle("queue", str(index), badge[&"at"], badge[&"text"]))
	for cabin: Dictionary in report.get(&"cabins", []):
		rows.append({"category": "EV", "id": cabin[&"shaft_id"], "rect": cabin[&"rect"], "style_source": "scripts/ui/pixel_tower_art.gd"})
		for actor: Dictionary in cabin[&"passengers"]:
			rows.append(actor_rectangle(actor))
	for actor: Dictionary in report.get(&"actor_drawings", []):
		rows.append(actor_rectangle(actor))
		if actor[&"staff"] and report[&"resting_staff"].has(StringName(String(actor[&"key"]).trim_prefix("staff/"))):
			var rest := actor_rectangle(actor)
			rest["category"] = "rest"
			rows.append(rest)
	for index: int in range(report.get(&"actor_aggregations", []).size()):
		var badge: Dictionary = report[&"actor_aggregations"][index]
		rows.append(badge_rectangle("aggregation", str(index), badge[&"at"], badge[&"text"]))
	for index: int in range(report.get(&"badges", []).size()):
		var badge: Dictionary = report[&"badges"][index]
		rows.append(badge_rectangle("goods" if badge[&"kind"] == &"supply" else "business", str(index), badge[&"at"], badge[&"text"]))
	for entry: Dictionary in report.get(&"traffic", []):
		var traffic: Dictionary = entry[&"traffic"]
		if traffic[&"current_density"] > 0 or traffic[&"temporary_block"]:
			var cell: Vector3i = entry[&"cell"]
			rows.append({"category": "traffic", "id": str(cell.x) + "," + str(cell.y) + "," + str(cell.z),
				"rect": entry[&"rect"], "style_source": "scenes/main/world_preview.gd"})
	var transform := view.get_global_transform_with_canvas()
	for row: Dictionary in rows:
		row["viewport_rect"] = transform * (row["rect"] as Rect2)
		row["screen_rect"] = view.get_screen_transform() * (row["rect"] as Rect2)
		var source: String = FileAccess.get_file_as_string("res://" + row["style_source"])
		var regex := RegEx.new()
		regex.compile('Color\\("([0-9a-fA-F]{6})"')
		var colors: Array = []
		for found: RegExMatch in regex.search_all(source):
			if not colors.has(found.get_string(1)): colors.append(found.get_string(1))
		row["style_colors"] = colors
	return {"rows": rows}

func badge_rectangle(category: String, id: String, at: Vector2, text: String) -> Dictionary:
	var width := ThemeDB.fallback_font.get_string_size(text, HORIZONTAL_ALIGNMENT_LEFT, -1, 10).x + 6
	return {"category": category, "id": id, "rect": Rect2(at, Vector2(text.length() * 10 + 6, 14)),
		"text": text, "font_width": width - 6, "style_source": "scenes/main/world_preview.gd"}

func actor_rectangle(actor: Dictionary) -> Dictionary:
	return {"category": "staff" if actor[&"staff"] else "guest", "id": actor[&"key"],
		"rect": Rect2(actor[&"at"], Vector2(16, 18) * float(actor[&"scale"])), "style_source": "scripts/ui/pixel_people.gd"}

func point(node: Control) -> Dictionary:
	var viewport: Vector2 = node.get_global_transform_with_canvas() * (node.size * 0.5)
	var screen: Vector2 = node.get_screen_transform() * (node.size * 0.5)
	return {"node": String(node.get_path()), "viewport": [viewport.x, viewport.y], "screen": [screen.x, screen.y], "window_id": node.get_window().get_window_id(),
		"viewport_to_screen": affine(node.get_screen_transform() * node.get_global_transform_with_canvas().affine_inverse())}

func setup() -> void:
	await super.setup()
	input_method = "native_os"
	expect(DisplayServer.get_name() != "headless", "real OS display")
	tree.root.title = "The Tree P23-03 " + layout + " " + role + " PID " + str(OS.get_process_id())
	input_observer = InputObserver.new()
	# No handler dispatch: this observer only records incoming OS events.
	tree.root.add_child(input_observer)
	json_file(role + "-profile.json", {"pid": OS.get_process_id(),
		"user_data_dir": OS.get_user_data_dir(), "engine": Engine.get_version_info(),
		"display": DisplayServer.get_name()})

func button(node: BaseButton) -> void:
	expect(node != null and not node.disabled, "reachable ordinary button")
	if node == null or node.disabled: return
	await request({"action": "click", "point": point(node), "button_text": str(node.get("text"))})

func load_menu(menu: MenuButton) -> void:
	var action := point(menu)
	action.merge({"action": "load_menu", "item_id": 0, "instructions": "Open this normal menu and choose manual load (item 0)."})
	await request(action)

func screenshot(label: String) -> void:
	await frames()
	await request({"action": "screenshot", "id": label, "layout": layout})

func layer_observations(prefix: String) -> void:
	if role == "writer" and prefix == "writer": await screenshot("calibration")
	await button(main.front_button)
	await screenshot(prefix + "-FRONT")
	await button(main.back_button)
	await screenshot(prefix + "-BACK")
	if role == "writer" and prefix == "writer": await ordinary_camera()

func ordinary_camera() -> void:
	var view: WorldPreview = main.world_preview
	var at := point(view)
	expect(not view.pan_mode, "ordinary zoom starts with move mode off")
	var zoom: float = view.zoom_level
	await request({"action": "wheel", "point": at, "direction": "down",
		"ctrl": false, "move_mode": false})
	expect(view.zoom_level != zoom, "ordinary wheel changes zoom")
	await screenshot("ordinary-wheel-zoom")
	await button(main.pan_button)
	await screenshot("pan-mode-button")
	expect(view.pan_mode, "PanModeButton enables move mode")
	zoom = view.zoom_level
	var pan: Vector2 = view.pan_offset
	await request({"action": "wheel", "point": point(view), "direction": "up",
		"ctrl": false, "move_mode": true})
	expect(view.pan_offset != pan and view.zoom_level == zoom, "ordinary move-mode wheel pans")
	await screenshot("move-mode-wheel-pan")

func finish_observations() -> void:
	json_file(role + "-requests.json", {"requests": all_requests, "pid": OS.get_process_id()})
	if is_instance_valid(input_observer): input_observer.queue_free()
	super.finish_observations()