class_name ABGFG2GrayboxController
extends Control

const Adapter = preload("res://campaign/p100_adapter.gd")
const Fixture = preload("res://campaign/fg2_fixture.gd")
const GrayboxLayer = preload("res://campaign/fg2_graybox_layer.gd")
const EventPresenter = preload("res://campaign/fg2_event_presenter.gd")
const AudioRouter = preload("res://campaign/fg2_audio_router.gd")

const SCREEN_MARKET := "market"
const SCREEN_BATTLE := "battle"
const SCREEN_REWARD := "reward"
const SCREEN_RECOVERY := "recovery"
const LAYER_KINDS := ["background", "midground", "actors", "foreground", "vfx"]
const TOUCH_DRAG_SLOP := 18.0
const INK := Color("0b1118")
const BAND := Color("111a24")
const TEXT := Color("e8eef2")
const MUTED_TEXT := Color("a9b7be")
const CYAN := Color("78c8c5")
const GOLD := Color("e0b95c")
const DANGER := Color("c65f54")

@export var locale := "zh_CN"
@export var text_scale := 1.0
@export var reduced_motion := false
@export var reduced_flashes := false
@export var muted := true
@export var low_power := false
@export var battle_auto_advance := true
@export var battle_tick_interval := 0.05
@export var battle_ticks_per_step := 4

var adapter = Adapter.new()
var event_presenter = EventPresenter.new()
var audio_router = AudioRouter.new()
var pending_snapshot: Dictionary = {}
var screen := SCREEN_MARKET
var view: Dictionary = {}
var selected_route_id := ""
var last_code := ""
var last_events: Array[Dictionary] = []
var presented_event_counts: Dictionary = {}
var battle_result_visible := false
var battle_paused := false
var battle_speed := 1
var inspect_open := false
var persistent_change_visible := false
var input_touch_count := 0
var input_drag_count := 0
var fallback_input_count := 0
var direct_command_count := 0
var logical_size := Vector2i(422, 195)
var logical_scale := 2
var logical_root: Control
var logical_base_position := Vector2.ZERO
var hud_root: Control
var feedback_root: Control
var actor_target_root: Control
var feedback_labels: Dictionary = {}
var layers: Array[Control] = []
var title_label: Label
var status_label: Label
var battle_accumulator := 0.0
var pulse := 0.0
var drag_touch_index := -1
var drag_source_id := ""
var drag_seen := false
var drag_input_counted := false
var owned_touch_index := -1
var owned_touch_button: Button
var owned_touch_mouse_filter := Control.MOUSE_FILTER_STOP
var owned_touch_start := Vector2.ZERO
var owned_touch_dragged := false
var raw_button_activation_count := 0


func configure_entry(snapshot_value: Dictionary) -> void:
	pending_snapshot = snapshot_value.duplicate(true)
	if is_inside_tree():
		_initialize_entry()


func show_failure_fixture() -> void:
	pending_snapshot = Fixture.recovery_market_state()
	_initialize_entry()


func _ready() -> void:
	set_process(true)
	set_process_input(true)
	clip_contents = true
	audio_router.attach(self)
	audio_router.configure(muted, low_power)
	_initialize_entry()


func _exit_tree() -> void:
	audio_router.cleanup()


func _notification(what: int) -> void:
	if what == NOTIFICATION_RESIZED and is_inside_tree() and logical_root != null:
		_layout_world()
		_request_render()


func _initialize_entry() -> void:
	var source := pending_snapshot if not pending_snapshot.is_empty() else Fixture.canonical_market_state()
	var result: Dictionary = adapter.configure(source)
	last_code = String(result.get("code", "configure_failed"))
	if not bool(result.get("ok", false)):
		return
	view = adapter.view_state(locale)
	selected_route_id = _route_id_for_risk(0)
	battle_result_visible = bool(view.get("battle", {}).get("terminal", false))
	persistent_change_visible = int(view.get("market_index", 0)) >= 2
	if bool(view.get("recovery_required", false)):
		screen = SCREEN_RECOVERY
	elif not Dictionary(view.get("reward", {})).is_empty():
		screen = SCREEN_REWARD
	elif String(view.get("phase", "")) == "encounter":
		screen = SCREEN_BATTLE
	else:
		screen = SCREEN_MARKET
	last_events.clear()
	presented_event_counts.clear()
	event_presenter.reset(view, reduced_motion, reduced_flashes, low_power)
	audio_router.reset(muted, low_power, screen == SCREEN_BATTLE)
	_build_world()
	_request_render()


func _build_world() -> void:
	if logical_root != null and is_instance_valid(logical_root):
		logical_root.queue_free()
	logical_root = Control.new()
	logical_root.name = "FG2LogicalWorld"
	logical_root.mouse_filter = Control.MOUSE_FILTER_IGNORE
	add_child(logical_root)
	if feedback_root != null and is_instance_valid(feedback_root):
		feedback_root.queue_free()
	feedback_root = Control.new()
	feedback_root.name = "FG2FeedbackRoot"
	feedback_root.set_anchors_and_offsets_preset(Control.PRESET_FULL_RECT)
	feedback_root.mouse_filter = Control.MOUSE_FILTER_IGNORE
	add_child(feedback_root)
	feedback_labels.clear()
	layers.clear()
	for kind in LAYER_KINDS:
		var layer = GrayboxLayer.new()
		layer.name = "%sLayer" % kind.capitalize()
		layer.configure(kind)
		logical_root.add_child(layer)
		layers.append(layer)
	_layout_world()


func _layout_world() -> void:
	var viewport := Vector2i(maxi(1, int(size.x)), maxi(1, int(size.y)))
	if viewport.x >= 1100 and viewport.y >= 650:
		logical_size = Vector2i(320, 180)
		logical_scale = 4
	elif viewport.x <= 800:
		logical_size = Vector2i(380, 180)
		logical_scale = 2
	else:
		logical_size = Vector2i(422, 195)
		logical_scale = 2
	logical_root.size = Vector2(logical_size)
	logical_root.scale = Vector2(logical_scale, logical_scale)
	var display_size := Vector2(logical_size * logical_scale)
	logical_base_position = Vector2(floor((size.x - display_size.x) * 0.5), floor((size.y - display_size.y) * 0.5))
	logical_root.position = logical_base_position
	for layer in layers:
		layer.position = Vector2.ZERO
		layer.size = Vector2(logical_size)
	set_meta("logical_grid", "%dx%d@%dx" % [logical_size.x, logical_size.y, logical_scale])
	set_meta("visible_world_ratio", minf(1.0, display_size.x * display_size.y / maxf(1.0, size.x * size.y)))
	_sync_world()


func _process(delta: float) -> void:
	pulse += delta
	event_presenter.advance(delta)
	audio_router.advance(delta)
	_apply_world_effects()
	if not low_power or int(pulse * 10.0) % 2 == 0:
		_sync_world()
	_sync_feedback_labels()
	if screen != SCREEN_BATTLE or battle_paused or battle_result_visible or not battle_auto_advance:
		return
	if event_presenter.blocks_auto_advance():
		return
	battle_accumulator += delta * float(battle_speed)
	if battle_accumulator < battle_tick_interval:
		return
	battle_accumulator = 0.0
	advance_battle_ticks(battle_ticks_per_step)


func advance_battle_ticks(count: int) -> Dictionary:
	var result: Dictionary = adapter.advance_battle_ticks(count, locale)
	last_code = String(result.get("code", "battle_advance_failed"))
	if not bool(result.get("ok", false)):
		return result
	view = adapter.view_state(locale)
	event_presenter.sync_view(view)
	_consume_events(result.get("events", []))
	battle_result_visible = bool(view.get("battle", {}).get("terminal", false))
	_sync_world()
	if battle_result_visible:
		_request_render()
	else:
		_update_status()
	return result


func _route_pressed(offer_id: String) -> void:
	selected_route_id = offer_id
	last_code = "route_selected"
	_request_render()


func _depart_pressed() -> void:
	if selected_route_id.is_empty():
		last_code = "route_required"
		_update_status()
		return
	var result: Dictionary = adapter.start_route(selected_route_id)
	last_code = String(result.get("code", "route_commit_failed"))
	if not bool(result.get("ok", false)):
		_update_status()
		return
	view = adapter.view_state(locale)
	screen = SCREEN_BATTLE
	battle_result_visible = false
	battle_paused = false
	battle_accumulator = 0.0
	last_events.clear()
	presented_event_counts.clear()
	event_presenter.reset(view, reduced_motion, reduced_flashes, low_power)
	event_presenter.begin_battle(view)
	audio_router.set_scene(true)
	var receipt: Dictionary = result.get("receipt", {})
	var operation_id := String(receipt.get("operation_id", ""))
	if not operation_id.is_empty():
		_consume_events([{
			"event_id": operation_id,
			"kind": "route_committed",
			"source_id": selected_route_id,
			"target_id": "windglass-route",
			"detail": {"offer_id": selected_route_id},
		}])
	_request_render()


func _settle_pressed() -> void:
	var result: Dictionary = adapter.settle_terminal(locale)
	last_code = String(result.get("code", "settlement_failed"))
	if not bool(result.get("ok", false)):
		_update_status()
		return
	view = adapter.view_state(locale)
	if bool(view.get("recovery_required", false)):
		screen = SCREEN_RECOVERY
	elif not Dictionary(view.get("reward", {})).is_empty():
		screen = SCREEN_REWARD
	else:
		screen = SCREEN_MARKET
	event_presenter.reset(view, reduced_motion, reduced_flashes, low_power)
	audio_router.set_scene(false)
	_request_render()


func _reward_pressed() -> void:
	var result: Dictionary = adapter.claim_coin_reward(locale)
	last_code = String(result.get("code", "reward_failed"))
	if not bool(result.get("ok", false)):
		_update_status()
		return
	view = adapter.view_state(locale)
	screen = SCREEN_MARKET
	persistent_change_visible = int(view.get("market_index", 0)) >= 2
	selected_route_id = _route_id_for_risk(0)
	event_presenter.reset(view, reduced_motion, reduced_flashes, low_power)
	audio_router.set_scene(false)
	_request_render()


func _recovery_pressed() -> void:
	var result: Dictionary = adapter.hire_protected_recovery(locale)
	last_code = String(result.get("code", "recovery_failed"))
	if not bool(result.get("ok", false)):
		_update_status()
		return
	view = adapter.view_state(locale)
	screen = SCREEN_MARKET
	selected_route_id = _route_id_for_risk(0)
	event_presenter.reset(view, reduced_motion, reduced_flashes, low_power)
	var receipt: Dictionary = result.get("receipt", {})
	var operation_id := String(receipt.get("operation_id", ""))
	var recruit_id := String(receipt.get("recruit_id", ""))
	if not operation_id.is_empty() and not recruit_id.is_empty():
		_consume_events([{
			"event_id": operation_id,
			"kind": "recovery",
			"source_id": "system",
			"target_id": recruit_id,
			"detail": {"credit_used": int(receipt.get("credit_used", 0))},
		}])
	_request_render()


func _pause_pressed() -> void:
	battle_paused = not battle_paused
	last_code = "battle_paused" if battle_paused else "battle_resumed"
	_request_render()


func _speed_pressed() -> void:
	battle_speed = 2 if battle_speed == 1 else 1
	last_code = "battle_speed_%d" % battle_speed
	_request_render()


func _inspect_pressed() -> void:
	inspect_open = not inspect_open
	last_code = "inspect_open" if inspect_open else "inspect_closed"
	_request_render()


func _input(event: InputEvent) -> void:
	if event is InputEventScreenTouch:
		var touch := event as InputEventScreenTouch
		if touch.pressed:
			input_touch_count += 1
			if owned_touch_index >= 0:
				return
			owned_touch_index = touch.index
			owned_touch_button = _button_at_point(touch.position)
			if owned_touch_button != null:
				owned_touch_mouse_filter = owned_touch_button.mouse_filter
				owned_touch_button.mouse_filter = Control.MOUSE_FILTER_IGNORE
			owned_touch_start = touch.position
			owned_touch_dragged = false
			var actor_id := _actor_at_point(touch.position)
			if screen == SCREEN_MARKET and not actor_id.is_empty():
				drag_touch_index = touch.index
				drag_source_id = actor_id
				drag_seen = false
				drag_input_counted = false
			if owned_touch_button != null or drag_touch_index >= 0:
				get_viewport().set_input_as_handled()
			else:
				_clear_touch_ownership()
		elif touch.index == owned_touch_index:
			get_viewport().set_input_as_handled()
			var release_button := _button_at_point(touch.position, owned_touch_button)
			var activate_button := (
				not touch.canceled
				and not owned_touch_dragged
				and owned_touch_button != null
				and is_instance_valid(owned_touch_button)
				and not owned_touch_button.is_queued_for_deletion()
				and release_button == owned_touch_button
			)
			var button_to_activate := owned_touch_button
			var button_instance_id := button_to_activate.get_instance_id() if is_instance_valid(button_to_activate) else 0
			var mouse_filter_to_restore := owned_touch_mouse_filter
			if touch.index == drag_touch_index and drag_seen:
				var target_id := _actor_at_point(touch.position)
				if not target_id.is_empty() and target_id != drag_source_id:
					_commit_drag_order(drag_source_id, target_id)
			_clear_touch_ownership()
			call_deferred("_restore_touch_button_mouse_filter", button_instance_id, mouse_filter_to_restore)
			if activate_button and is_instance_valid(button_to_activate):
				raw_button_activation_count += 1
				button_to_activate.emit_signal(&"pressed")
	elif event is InputEventScreenDrag and event.index == owned_touch_index:
		var drag := event as InputEventScreenDrag
		get_viewport().set_input_as_handled()
		if drag.position.distance_to(owned_touch_start) >= TOUCH_DRAG_SLOP:
			owned_touch_dragged = true
		if drag.index == drag_touch_index and not drag_source_id.is_empty():
			if not drag_input_counted:
				input_drag_count += 1
				drag_input_counted = true
			if drag.position.distance_to(owned_touch_start) >= TOUCH_DRAG_SLOP:
				drag_seen = true


func _commit_drag_order(source_id: String, target_id: String) -> void:
	var order: Array = Array(adapter.market.state.current_run.deployed_recruit_ids).duplicate()
	var source_index := order.find(source_id)
	var target_index := order.find(target_id)
	if source_index < 0 or target_index < 0:
		return
	order.remove_at(source_index)
	order.insert(target_index, source_id)
	var result: Dictionary = adapter.commit_order(order)
	last_code = String(result.get("code", "formation_failed"))
	if bool(result.get("ok", false)):
		view = adapter.view_state(locale)
	_request_render()


func _button_at_point(point: Vector2, allowed_ignored_button: Button = null) -> Button:
	if hud_root == null or not is_instance_valid(hud_root):
		return null
	var canvas_point := get_viewport().get_final_transform().affine_inverse() * point
	var best: Button
	var best_z := -2147483648
	for node in hud_root.find_children("*", "Button", true, false):
		var button := node as Button
		if button == null or button.disabled:
			continue
		if button.mouse_filter == Control.MOUSE_FILTER_IGNORE and button != allowed_ignored_button:
			continue
		if not button.is_visible_in_tree() or button.is_queued_for_deletion():
			continue
		if not button.get_global_rect().has_point(canvas_point):
			continue
		var effective_z := _effective_z_index(button)
		if best == null or effective_z >= best_z:
			best = button
			best_z = effective_z
	return best


func _effective_z_index(item: CanvasItem) -> int:
	var result := item.z_index
	var ancestor := item.get_parent()
	while item.z_as_relative and ancestor is CanvasItem:
		var canvas_ancestor := ancestor as CanvasItem
		result += canvas_ancestor.z_index
		item = canvas_ancestor
		ancestor = item.get_parent()
	return result


func _clear_touch_ownership() -> void:
	owned_touch_index = -1
	owned_touch_button = null
	owned_touch_mouse_filter = Control.MOUSE_FILTER_STOP
	owned_touch_start = Vector2.ZERO
	owned_touch_dragged = false
	drag_touch_index = -1
	drag_source_id = ""
	drag_seen = false
	drag_input_counted = false


func _restore_touch_button_mouse_filter(instance_id: int, mouse_filter: int) -> void:
	var button := instance_from_id(instance_id) as Button if instance_id > 0 else null
	if button != null and not button.is_queued_for_deletion():
		button.mouse_filter = mouse_filter


func _consume_events(events: Array) -> void:
	for raw_event in events:
		var event: Dictionary = raw_event
		last_events.append(event.duplicate(true))
		var kind := String(event.get("kind", ""))
		presented_event_counts[kind] = int(presented_event_counts.get(kind, 0)) + 1
	while last_events.size() > 12:
		last_events.pop_front()
	event_presenter.consume(events)
	audio_router.consume(events)


func set_audio_options(mute_value: bool, power_value: bool) -> void:
	muted = mute_value
	low_power = power_value
	audio_router.configure(muted, low_power)


func _request_render() -> void:
	if not is_inside_tree():
		return
	call_deferred("_render_hud")


func _render_hud() -> void:
	if hud_root != null and is_instance_valid(hud_root):
		hud_root.queue_free()
	hud_root = Control.new()
	hud_root.name = "FG2HudRoot"
	hud_root.set_anchors_and_offsets_preset(Control.PRESET_FULL_RECT)
	add_child(hud_root)
	var top_band := ColorRect.new()
	top_band.name = "FG2TopBand"
	top_band.color = BAND * Color(1, 1, 1, 0.92)
	top_band.position = Vector2.ZERO
	top_band.size = Vector2(size.x, 48)
	top_band.mouse_filter = Control.MOUSE_FILTER_IGNORE
	hud_root.add_child(top_band)
	title_label = _label("FG2Title", _title_text(), Vector2(18, 5), Vector2(size.x - 36, 25), 17, TEXT)
	status_label = _label("FG2Status", _status_text(), Vector2(18, 25), Vector2(size.x - 36, 20), 12, MUTED_TEXT)
	match screen:
		SCREEN_MARKET:
			_render_market_controls()
		SCREEN_BATTLE:
			_render_battle_controls()
		SCREEN_REWARD:
			_render_reward_controls()
		SCREEN_RECOVERY:
			_render_recovery_controls()
	_render_actor_targets()
	_sync_world()


func _render_market_controls() -> void:
	var routes: Array = view.get("routes", [])
	var button_width := clampf((size.x - 42.0) / 3.0, 112.0, 190.0)
	var total_width := button_width * routes.size() + 8.0 * maxi(0, routes.size() - 1)
	var start_x := maxf(16.0, size.x - total_width - 16.0)
	for index in range(routes.size()):
		var route: Dictionary = routes[index]
		var risk := int(route.get("risk", 0))
		var text := _tr("稳妥", "STEADY") if risk == 0 else _tr("应变", "ADAPT") if risk == 1 else _tr("险境", "PERIL")
		text += "  %d%s" % [int(route.get("wave_count", 0)), _tr("波", " WAVES")]
		var button := _button("FG2Route_%s" % String(route.offer_id), text, Rect2(start_x + index * (button_width + 8), size.y - 120, button_width, 52), _route_pressed.bind(String(route.offer_id)), String(route.offer_id) == selected_route_id, risk == 2)
		button.tooltip_text = ", ".join(route.get("enemy_names", []))
	_button("FG2ReverseLineButton", _tr("调换战线", "REVERSE LINE"), Rect2(16, size.y - 60, 158, 48), _reverse_line_pressed)
	_button("FG2DepartButton", _tr("开始远征", "BEGIN EXPEDITION"), Rect2(size.x - 198, size.y - 62, 182, 52), _depart_pressed, true)
	if persistent_change_visible:
		_label("FG2PersistentChange", _tr("市场 2 已保存 · 风道恢复一段", "MARKET 2 SAVED · CHANNEL RESTORED"), Vector2(size.x * 0.25, 56), Vector2(size.x * 0.5, 26), 14, GOLD, HORIZONTAL_ALIGNMENT_CENTER)


func _render_battle_controls() -> void:
	_button("FG2PauseButton", _tr("继续", "RESUME") if battle_paused else _tr("暂停", "PAUSE"), Rect2(16, size.y - 60, 92, 48), _pause_pressed)
	_button("FG2SpeedButton", "%dx" % battle_speed, Rect2(116, size.y - 60, 74, 48), _speed_pressed)
	_button("FG2InspectButton", _tr("收起", "CLOSE") if inspect_open else _tr("战况", "INSPECT"), Rect2(198, size.y - 60, 100, 48), _inspect_pressed)
	if battle_result_visible:
		_button("FG2SettleButton", _tr("领取战果", "SETTLE RESULT"), Rect2(size.x - 190, size.y - 62, 174, 52), _settle_pressed, true)
	if inspect_open:
		var decisive: Dictionary = view.get("battle", {}).get("first_decisive_event", {})
		var detail := _tr("关键因果：尚未发生", "DECISIVE CAUSE: PENDING")
		if not decisive.is_empty():
			detail = _tr("关键因果：%s → %s" % [String(decisive.get("source_id", "")), String(decisive.get("target_id", ""))], "DECISIVE CAUSE: %s -> %s" % [String(decisive.get("source_id", "")), String(decisive.get("target_id", ""))])
		_label("FG2InspectReadout", detail, Vector2(size.x * 0.23, 54), Vector2(size.x * 0.54, 26), 13, GOLD, HORIZONTAL_ALIGNMENT_CENTER)


func _render_reward_controls() -> void:
	var reward: Dictionary = view.get("reward", {})
	var amount := 0
	for card in reward.get("cards", []):
		if String(card.get("kind", "")) == "coin":
			amount = int(card.get("amount", 0))
	_label("FG2RewardHeadline", _tr("战线守住了", "THE LINE HELD"), Vector2(size.x * 0.25, size.y * 0.24), Vector2(size.x * 0.5, 36), 24, TEXT, HORIZONTAL_ALIGNMENT_CENTER)
	_label("FG2RewardCause", _tr("敌军溃退，市场通道向前推进。", "THE ENEMY BROKE; THE MARKET CHANNEL ADVANCES."), Vector2(size.x * 0.20, size.y * 0.34), Vector2(size.x * 0.6, 30), 14, MUTED_TEXT, HORIZONTAL_ALIGNMENT_CENTER)
	_button("FG2RewardButton", _tr("收下 %d 金币" % amount, "TAKE %d COIN" % amount), Rect2(size.x * 0.5 - 105, size.y - 90, 210, 56), _reward_pressed, true)


func _render_recovery_controls() -> void:
	_label("FG2RecoveryHeadline", _tr("战线出现永久缺口", "THE LINE HAS A PERMANENT GAP"), Vector2(size.x * 0.20, size.y * 0.22), Vector2(size.x * 0.6, 36), 22, DANGER, HORIZONTAL_ALIGNMENT_CENTER)
	_label("FG2RecoveryCause", _tr("阵亡成员不会复活。保护性补员会加入现有幸存者。", "FALLEN RECRUITS DO NOT RETURN. A PROTECTED HIRE JOINS THE SURVIVORS."), Vector2(size.x * 0.14, size.y * 0.33), Vector2(size.x * 0.72, 46), 14, TEXT, HORIZONTAL_ALIGNMENT_CENTER)
	_button("FG2RecoveryButton", _tr("补员并重整战线", "HIRE AND REFORM"), Rect2(size.x * 0.5 - 120, size.y - 92, 240, 56), _recovery_pressed, true)


func _render_actor_targets() -> void:
	actor_target_root = Control.new()
	actor_target_root.name = "FG2ActorTargets"
	actor_target_root.set_anchors_and_offsets_preset(Control.PRESET_FULL_RECT)
	actor_target_root.mouse_filter = Control.MOUSE_FILTER_IGNORE
	hud_root.add_child(actor_target_root)
	var company: Array = view.get("company", [])
	if screen == SCREEN_BATTLE:
		var allies: Array = view.get("battle", {}).get("allies", [])
		var enemies: Array = view.get("battle", {}).get("enemies", [])
		for index in range(allies.size()):
			_add_actor_target(String(allies[index].actor_id), allies[index], _battle_actor_logical(index, false), false)
		for index in range(enemies.size()):
			_add_actor_target(String(enemies[index].actor_id), enemies[index], _battle_actor_logical(index, true), true)
	else:
		var deployed_index := 0
		for actor in company:
			if not bool(actor.get("deployed", false)):
				continue
			_add_actor_target(String(actor.recruit_id), actor, Vector2(47 + deployed_index * 44, logical_size.y * 0.63), false)
			deployed_index += 1


func _add_actor_target(actor_id: String, actor: Dictionary, logical_position: Vector2, enemy: bool) -> void:
	var target := Control.new()
	target.name = ("FG2EnemyTarget_" if enemy else "FG2CompanyTarget_") + actor_id
	var center := logical_root.position + logical_position * float(logical_scale)
	var target_size := Vector2(maxf(48, 25 * logical_scale), maxf(56, 34 * logical_scale))
	target.position = center - Vector2(target_size.x * 0.5, target_size.y * 0.72)
	target.size = target_size
	target.mouse_filter = Control.MOUSE_FILTER_IGNORE
	actor_target_root.add_child(target)
	var label := Label.new()
	label.name = "Identity"
	var label_width := maxf(86, target_size.x + 28)
	label.position = Vector2((target_size.x - label_width) * 0.5, target_size.y - 8)
	label.size = Vector2(label_width, 20)
	label.text = String(actor.get("profession_name", actor.get("name", actor.get("identity_id", ""))))
	label.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
	label.text_overrun_behavior = TextServer.OVERRUN_TRIM_ELLIPSIS
	var identity_font_size := maxi(9, int(10 * text_scale))
	if label.text.length() > 9:
		identity_font_size = maxi(9, identity_font_size - 2)
	label.add_theme_font_size_override("font_size", identity_font_size)
	label.add_theme_color_override("font_color", DANGER.lightened(0.30) if enemy else TEXT)
	label.mouse_filter = Control.MOUSE_FILTER_IGNORE
	target.add_child(label)


func _reverse_line_pressed() -> void:
	var order: Array = Array(adapter.market.state.current_run.deployed_recruit_ids).duplicate()
	order.reverse()
	var result: Dictionary = adapter.commit_order(order)
	last_code = String(result.get("code", "formation_failed"))
	if bool(result.get("ok", false)):
		view = adapter.view_state(locale)
	_request_render()


func _sync_world() -> void:
	var presentation := event_presenter.snapshot()
	for layer in layers:
		if is_instance_valid(layer):
			layer.sync(screen, view, last_events, pulse, reduced_motion, presentation)


func _apply_world_effects() -> void:
	if logical_root == null or not is_instance_valid(logical_root):
		return
	logical_root.position = logical_base_position + Vector2(event_presenter.shake_offset())


func _sync_feedback_labels() -> void:
	if feedback_root == null or not is_instance_valid(feedback_root):
		return
	var presentation := event_presenter.snapshot()
	var candidates: Array = []
	for transient in presentation.get("transients", []):
		if not String(transient.get("text", "")).is_empty():
			candidates.append(transient)
	if candidates.size() > 4:
		candidates = candidates.slice(candidates.size() - 4, candidates.size())
	var active_ids: Dictionary = {}
	var actor_stack_counts: Dictionary = {}
	for transient in candidates:
		var event_id := String(transient.get("event_id", ""))
		var actor_id := String(transient.get("target_id", ""))
		if actor_id.is_empty():
			actor_id = String(transient.get("source_id", ""))
		var logical_position := _presentation_actor_logical(actor_id)
		if logical_position == Vector2.ZERO and String(transient.get("kind", "")) == "outcome":
			logical_position = Vector2(logical_size.x * 0.5, logical_size.y * 0.46)
		if event_id.is_empty() or logical_position == Vector2.ZERO:
			continue
		var stack_index := int(actor_stack_counts.get(actor_id, 0))
		actor_stack_counts[actor_id] = stack_index + 1
		active_ids[event_id] = true
		var label: Label = feedback_labels.get(event_id) as Label
		if label == null:
			label = Label.new()
			label.name = "FG2Feedback_%s" % event_id
			label.size = Vector2(132, 28)
			label.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
			label.vertical_alignment = VERTICAL_ALIGNMENT_CENTER
			label.mouse_filter = Control.MOUSE_FILTER_IGNORE
			label.add_theme_font_size_override("font_size", maxi(13, int(15 * text_scale)))
			label.add_theme_constant_override("outline_size", 4)
			label.add_theme_color_override("font_outline_color", INK)
			feedback_root.add_child(label)
			feedback_labels[event_id] = label
		label.text = _localized_feedback_text(transient)
		label.add_theme_color_override("font_color", _feedback_color(String(transient.get("kind", ""))))
		var progress := float(transient.get("progress", 0.0))
		var center := logical_base_position + Vector2(event_presenter.shake_offset()) + logical_position * float(logical_scale)
		label.position = Vector2(floor(center.x - label.size.x * 0.5), floor(center.y - 76.0 - progress * 18.0 - stack_index * 22.0))
		label.modulate.a = clampf(1.0 - progress * progress, 0.0, 1.0)
	for event_id in feedback_labels.keys():
		if active_ids.has(event_id):
			continue
		var label: Label = feedback_labels[event_id]
		if is_instance_valid(label):
			label.queue_free()
		feedback_labels.erase(event_id)


func _presentation_actor_logical(actor_id: String) -> Vector2:
	if screen != SCREEN_BATTLE:
		var deployed_index := 0
		var reserve_index := 0
		for actor in view.get("company", []):
			if String(actor.get("recruit_id", "")) == actor_id:
				if bool(actor.get("deployed", false)):
					return Vector2(47 + deployed_index * 44, logical_size.y * 0.63)
				return Vector2(32 + reserve_index * 25, logical_size.y * 0.66)
			if bool(actor.get("deployed", false)):
				deployed_index += 1
			else:
				reserve_index += 1
	var battle: Dictionary = view.get("battle", {})
	var allies: Array = battle.get("allies", [])
	var enemies: Array = battle.get("enemies", [])
	for index in range(allies.size()):
		if String(allies[index].get("actor_id", "")) == actor_id:
			return _battle_actor_logical(index, false)
	for index in range(enemies.size()):
		if String(enemies[index].get("actor_id", "")) == actor_id:
			return _battle_actor_logical(index, true)
	var cue: Dictionary = event_presenter.snapshot().get("actor_cues", {}).get(actor_id, {})
	if not cue.is_empty():
		return _battle_actor_logical(int(cue.get("slot_index", 0)), String(cue.get("side", "")) == "enemy")
	return Vector2.ZERO


func _feedback_color(kind: String) -> Color:
	if kind == "damage" or kind == "fallen":
		return DANGER.lightened(0.25)
	if kind == "heal":
		return CYAN.lightened(0.25)
	if kind in ["guard", "intercept", "item_block", "push_resisted", "mitigation"]:
		return GOLD
	return TEXT


func _localized_feedback_text(transient: Dictionary) -> String:
	var kind := String(transient.get("kind", ""))
	var value := int(transient.get("value", 0))
	match kind:
		"damage":
			return "-%d" % value
		"heal":
			return "+%d" % value
		"guard":
			return _tr("+%d 护盾" % value, "+%d GUARD" % value)
		"mitigation":
			return _tr("%d 格挡" % value, "%d BLOCKED" % value)
		"intercept", "item_block", "push_resisted":
			return _tr("格挡", "BLOCK")
		"hinder":
			return _tr("-%d 就绪" % value, "-%d READY" % value)
		"fallen":
			return _tr("阵亡", "FALLEN")
		"outcome":
			var outcome := String(transient.get("text", "")).to_lower()
			return _tr("胜利", "VICTORY") if outcome == "victory" else _tr("败退", "DEFEAT")
		"recovery":
			return _tr("补员完成", "RECOVERED")
	return String(transient.get("text", ""))


func _update_status() -> void:
	if status_label != null and is_instance_valid(status_label):
		status_label.text = _status_text()


func _title_text() -> String:
	match screen:
		SCREEN_BATTLE:
			return _tr("风晶峡道 · 自动交战", "WINDGLASS CHANNEL · AUTO BATTLE")
		SCREEN_REWARD:
			return _tr("远征结算", "EXPEDITION RESULT")
		SCREEN_RECOVERY:
			return _tr("战线恢复", "LINE RECOVERY")
	return _tr("风晶市场 %d · 编队与路线" % int(view.get("market_index", 1)), "WINDGLASS MARKET %d · LINE & ROUTE" % int(view.get("market_index", 1)))


func _status_text() -> String:
	if screen == SCREEN_BATTLE:
		var battle_view: Dictionary = view.get("battle", {})
		if bool(battle_view.get("terminal", false)):
			return _tr("结果：%s · 首个决定性因果已记录" % _outcome_label(String(battle_view.get("outcome", ""))), "RESULT: %s · FIRST DECISIVE CAUSE RECORDED" % _outcome_label(String(battle_view.get("outcome", ""))))
		return _tr("第 %d/%d 波 · 自动攻击 · 点“战况”查看因果" % [int(battle_view.get("next_wave", 0)), int(battle_view.get("wave_count", 0))], "WAVE %d/%d · AUTO ATTACK · INSPECT CAUSE" % [int(battle_view.get("next_wave", 0)), int(battle_view.get("wave_count", 0))])
	if screen == SCREEN_RECOVERY:
		return _tr("幸存 %d 人 · 信用 %d · 保护补员待确认" % [view.get("company", []).size(), int(view.get("replacement_credit", 0))], "%d SURVIVORS · %d CREDIT · PROTECTED HIRE READY" % [view.get("company", []).size(), int(view.get("replacement_credit", 0))])
	if screen == SCREEN_REWARD:
		return _tr("胜利奖励只结算一次", "VICTORY REWARD COMMITS ONCE")
	var selected := _selected_route()
	if selected.is_empty():
		return _tr("先选路线；可拖动队员调整自动战线", "CHOOSE A ROUTE; DRAG RECRUITS TO CHANGE AUTO LINE")
	return _tr("已选风险 %d · %d 波 · 拖动队员可改变承伤顺序" % [int(selected.risk), int(selected.wave_count)], "RISK %d · %d WAVES · DRAG TO CHANGE HIT ORDER" % [int(selected.risk), int(selected.wave_count)])


func _button(name_value: String, text_value: String, rect: Rect2, callback: Callable, selected := false, danger := false) -> Button:
	var button := Button.new()
	button.name = name_value
	button.position = Vector2(floor(rect.position.x), floor(rect.position.y))
	button.size = Vector2(maxf(48, floor(rect.size.x)), maxf(48, floor(rect.size.y)))
	button.text = text_value
	button.add_theme_font_size_override("font_size", maxi(12, int(13 * text_scale)))
	button.add_theme_color_override("font_color", TEXT)
	button.add_theme_color_override("font_hover_color", TEXT)
	button.add_theme_stylebox_override("normal", _style(DANGER.darkened(0.42) if danger else CYAN.darkened(0.62) if selected else BAND, CYAN if selected else DANGER if danger else MUTED_TEXT.darkened(0.35)))
	button.add_theme_stylebox_override("hover", _style(DANGER.darkened(0.22) if danger else CYAN.darkened(0.45), TEXT))
	button.add_theme_stylebox_override("pressed", _style(CYAN.darkened(0.30), GOLD))
	button.pressed.connect(callback)
	hud_root.add_child(button)
	return button


func _label(name_value: String, text_value: String, position_value: Vector2, size_value: Vector2, font_size: int, color: Color, alignment := HORIZONTAL_ALIGNMENT_LEFT) -> Label:
	var label := Label.new()
	label.name = name_value
	label.position = Vector2(floor(position_value.x), floor(position_value.y))
	label.size = Vector2(floor(size_value.x), floor(size_value.y))
	label.text = text_value
	label.horizontal_alignment = alignment
	label.vertical_alignment = VERTICAL_ALIGNMENT_CENTER
	label.text_overrun_behavior = TextServer.OVERRUN_TRIM_ELLIPSIS
	label.add_theme_font_size_override("font_size", maxi(10, int(font_size * text_scale)))
	label.add_theme_color_override("font_color", color)
	label.mouse_filter = Control.MOUSE_FILTER_IGNORE
	hud_root.add_child(label)
	return label


func _style(fill: Color, border: Color) -> StyleBoxFlat:
	var style := StyleBoxFlat.new()
	style.bg_color = fill
	style.border_color = border
	style.set_border_width_all(2)
	style.corner_radius_top_left = 2
	style.corner_radius_top_right = 2
	style.corner_radius_bottom_left = 2
	style.corner_radius_bottom_right = 2
	return style


func _actor_at_point(point: Vector2) -> String:
	if actor_target_root == null:
		return ""
	for child in actor_target_root.get_children():
		if child is Control and child.get_global_rect().has_point(point):
			var raw := String(child.name)
			if raw.begins_with("FG2CompanyTarget_"):
				return raw.trim_prefix("FG2CompanyTarget_")
	return ""


func _battle_actor_logical(index: int, enemy: bool) -> Vector2:
	if enemy:
		return Vector2(logical_size.x * 0.66 + index * 34, logical_size.y * 0.69 + (index % 2) * 5)
	return Vector2(logical_size.x * 0.39 - index * 38, logical_size.y * 0.69 + (index % 2) * 4)


func _route_id_for_risk(risk: int) -> String:
	for route in view.get("routes", []):
		if int(route.get("risk", -1)) == risk:
			return String(route.get("offer_id", ""))
	return ""


func _selected_route() -> Dictionary:
	for route in view.get("routes", []):
		if String(route.get("offer_id", "")) == selected_route_id:
			return route
	return {}


func _outcome_label(outcome: String) -> String:
	return {"victory": _tr("胜利", "VICTORY"), "defeat": _tr("败退", "DEFEAT"), "retreat": _tr("撤退", "RETREAT")}.get(outcome, outcome.to_upper())


func _tr(zh: String, en: String) -> String:
	return en if locale == "en" else zh