class_name RhythmTrack
extends Control

@onready var judgement_label: Label = $JudgementLabel
@onready var track_background: TextureRect = $TrackBackground
@onready var track_line: TextureRect = $TrackLine
@onready var center_base: TextureRect = $CenterBase
@onready var center_flash: TextureRect = $CenterFlash
@onready var left_mover: TextureRect = $LeftMover
@onready var right_mover: TextureRect = $RightMover
@onready var chart_marker_container: Control = $ChartMarkerContainer
@onready var combo_count_label: Label = $HudReadoutRow/ComboCountLabel
@onready var attack_buff_value_label: Label = $HudReadoutRow/AttackBuffValueLabel
@onready var buff_pip_row: HBoxContainer = $BuffPipRow
@onready var judgement_art: TextureRect = $JudgementArt

@export var bpm := 80.0
@export var responsive_layout := true

# Full track skin per time phase: map A (past) is the purple/gold set, map B
# (future) the red "d" set. Time anchors never add screen elements — the mover
# itself swaps to the special-beat texture. A held special beat shows the
# OTHER phase's hit emblem (cross variant) while the flash stays own-phase.
const TRACK_SKINS := {
	&"past": {
		&"background": preload("res://assets/ui/rhythm/b.png"),
		&"center_idle": preload("res://assets/ui/rhythm/anchor01.png"),
		&"center_hit_normal": preload("res://assets/ui/rhythm/anchor02.png"),
		&"center_hit_special": preload("res://assets/ui/rhythm/anchor02d.png"),
		&"flash_normal": preload("res://assets/ui/rhythm/c01.png"),
		&"flash_special": preload("res://assets/ui/rhythm/c02.png"),
		&"mover_normal": preload("res://assets/ui/rhythm/star.png"),
		&"mover_special": preload("res://assets/ui/rhythm/sanchor.png"),
	},
	&"future": {
		&"background": preload("res://assets/ui/rhythm/bd.png"),
		&"center_idle": preload("res://assets/ui/rhythm/anchor01d.png"),
		&"center_hit_normal": preload("res://assets/ui/rhythm/anchor02d.png"),
		&"center_hit_special": preload("res://assets/ui/rhythm/anchor02.png"),
		&"flash_normal": preload("res://assets/ui/rhythm/c01d.png"),
		&"flash_special": preload("res://assets/ui/rhythm/c02d.png"),
		&"mover_normal": preload("res://assets/ui/rhythm/stard.png"),
		&"mover_special": preload("res://assets/ui/rhythm/sanchord.png"),
	},
}

const DESIGN_SIZE := Vector2(1280.0, 720.0)
const HUD_MIN_SCALE := 0.72
const HUD_MAX_SCALE := 1.15
const CENTER_HIT_HOLD_SECONDS := 0.62
const BEAT_TICK_FLASH_PEAK := 0.35
const BEAT_FLASH_DECAY_RATE := 8.0
const CENTER_HIT_FLASH_DECAY_RATE := 2.8
const CENTER_HIT_FLASH_SCALE := 1.55
const TIME_ANCHOR_HELD_COLOR := Color(0.45, 1.0, 0.75)
const TIME_ANCHOR_BROKEN_COLOR := Color(1.0, 0.2, 0.9)
const TIME_ANCHOR_MOVER_SCALE := 1.65
const BUFF_SLOT_COUNT := 7
const BUFF_ON_TEXTURE := preload("res://assets/ui/buff/buff_on.png")
const BUFF_OFF_TEXTURE := preload("res://assets/ui/buff/buff_off.png")
const JUDGEMENT_ARTS := {
	&"perfect": preload("res://assets/ui/judgements/perfect.png"),
	&"good": preload("res://assets/ui/judgements/good.png"),
	&"bad": preload("res://assets/ui/judgements/bad.png"),
	&"miss": preload("res://assets/ui/judgements/miss.png"),
}
## 2026-07-05 策划：判定字样显示 1 秒后自动消失；新判定顶替时重置计时。
const JUDGEMENT_VISIBLE_SECONDS := 1.0

var chart_markers: Array[Control] = []
var _time_anchor_beats: Dictionary = {}
var _last_beat_index := -1
var _last_upcoming_beat := -1
var _time_phase: StringName = &"past"
var _streak_count := 0
var _attack_buff_stacks := 0
var _attack_buff_max := BUFF_SLOT_COUNT
var _center_hit_timer := 0.0
var _judgement_visible_left := 0.0
var _time_anchor_feedback_latched := false
var track_center := Vector2.ZERO
var left_mover_start := Vector2.ZERO
var right_mover_start := Vector2.ZERO
var mover_size := Vector2.ZERO
var normal_mover_size := Vector2.ZERO
var time_anchor_mover_size := Vector2.ZERO
var center_flash_size := Vector2.ZERO
var normal_center_flash_size := Vector2.ZERO
var hit_center_flash_size := Vector2.ZERO
var center_flash_decay_rate := BEAT_FLASH_DECAY_RATE
var center_flash_color := Color.WHITE
var center_flash_peak := 1.0
var beat_flash := 0.0
var beat_age := 0.0
var feedback_flash := 0.0
var _last_layout_size := Vector2.ZERO
var _responsive_scale := 1.0


func _ready() -> void:
	_apply_responsive_layout()
	_cache_rhythm_track_layout()
	center_flash.modulate = Color(1.0, 1.0, 1.0, 0.0)
	_sync_bpm_with_rhythm_manager()
	_apply_time_phase_skin(_initial_time_phase())
	_refresh_combo_count()
	_refresh_attack_buff_display()
	var bus := _event_bus()
	bus.connect("beat_ticked", _on_beat_ticked)
	bus.connect("judgement_made", _on_judgement_made)
	bus.connect("chart_event_upcoming", _on_chart_event_upcoming)
	bus.connect("chart_event_triggered", _on_chart_event_triggered)
	if bus.has_signal("time_anchor_scheduled"):
		bus.connect("time_anchor_scheduled", _on_time_anchor_scheduled)
	if bus.has_signal("time_anchor_resolved"):
		bus.connect("time_anchor_resolved", _on_time_anchor_resolved)
	if bus.has_signal("time_phase_changed"):
		bus.connect("time_phase_changed", _on_time_phase_changed)
	if bus.has_signal("chart_reset"):
		bus.connect("chart_reset", _on_chart_reset_clear_time_anchor_markers)
	if bus.has_signal("streak_changed"):
		bus.connect("streak_changed", _on_streak_changed)
	if bus.has_signal("attack_buff_changed"):
		bus.connect("attack_buff_changed", _on_attack_buff_changed)


func _apply_responsive_layout() -> void:
	if not responsive_layout:
		return
	var viewport_size := size
	if viewport_size.x <= 0.0 or viewport_size.y <= 0.0:
		viewport_size = get_viewport_rect().size
	if viewport_size.x <= 0.0 or viewport_size.y <= 0.0:
		return
	_last_layout_size = viewport_size
	_responsive_scale = _hud_scale(viewport_size)
	var s := _responsive_scale
	var center_x := viewport_size.x * 0.5
	var track_y := viewport_size.y - 94.0 * s
	var axis_y := track_y + 18.0 * s
	var track_max_w := maxf(320.0 * s, viewport_size.x - 96.0 * s)
	var track_w := minf(832.0 * s, track_max_w)

	_set_control_rect(track_background, Vector2(center_x, track_y + 14.0 * s), Vector2(track_w, 116.0 * s))
	_set_control_rect(track_line, Vector2(center_x, axis_y), Vector2(maxf(120.0 * s, track_w - 100.0 * s), 47.0 * s))
	_set_control_rect(center_base, Vector2(center_x, axis_y), Vector2(112.0 * s, 131.0 * s))
	_set_control_rect(center_flash, Vector2(center_x, axis_y), Vector2(160.0 * s, 151.0 * s))
	normal_center_flash_size = center_flash.size
	hit_center_flash_size = normal_center_flash_size * CENTER_HIT_FLASH_SCALE
	_set_center_flash_profile(false)
	normal_mover_size = Vector2(68.0 * s, 62.0 * s)
	time_anchor_mover_size = normal_mover_size * TIME_ANCHOR_MOVER_SCALE
	_set_control_rect(left_mover, Vector2(center_x - track_w * 0.43, axis_y), normal_mover_size)
	_set_control_rect(right_mover, Vector2(center_x + track_w * 0.43, axis_y), normal_mover_size)

	_set_control_top_left(chart_marker_container, Vector2.ZERO, viewport_size)
	_set_control_top_left($HudReadoutRow, Vector2(154.0 * s, 135.0 * s), Vector2(260.0 * s, 76.0 * s))
	combo_count_label.custom_minimum_size = Vector2(240.0 * s, 32.0 * s)
	attack_buff_value_label.custom_minimum_size = Vector2(240.0 * s, 32.0 * s)
	combo_count_label.add_theme_font_size_override("font_size", int(round(26.0 * s)))
	attack_buff_value_label.add_theme_font_size_override("font_size", int(round(26.0 * s)))

	var buff_total_w := (42.0 * 7.0 + 12.0 * 6.0) * s
	_set_control_top_left(buff_pip_row, Vector2(center_x - buff_total_w * 0.5, 132.0 * s), Vector2(buff_total_w, 58.0 * s))
	buff_pip_row.add_theme_constant_override("separation", int(round(12.0 * s)))
	for child: Node in buff_pip_row.get_children():
		var pip := child as TextureRect
		if pip != null:
			pip.custom_minimum_size = Vector2(42.0 * s, 55.0 * s)

	var judgement_center := Vector2(center_x, viewport_size.y * 0.56)
	_set_control_rect(judgement_art, judgement_center, Vector2(270.0 * s, 72.0 * s))
	_set_control_rect(judgement_label, judgement_center, Vector2(500.0 * s, 74.0 * s))
	judgement_label.add_theme_font_size_override("font_size", int(round(32.0 * s)))
	_cache_rhythm_track_layout()


func _hud_scale(viewport_size: Vector2) -> float:
	return clampf(minf(viewport_size.x / DESIGN_SIZE.x, viewport_size.y / DESIGN_SIZE.y), HUD_MIN_SCALE, HUD_MAX_SCALE)


func _set_control_rect(control: Control, center: Vector2, target_size: Vector2) -> void:
	control.offset_left = center.x - target_size.x * 0.5
	control.offset_top = center.y - target_size.y * 0.5
	control.offset_right = center.x + target_size.x * 0.5
	control.offset_bottom = center.y + target_size.y * 0.5


func _set_control_top_left(control: Control, top_left: Vector2, target_size: Vector2) -> void:
	control.offset_left = top_left.x
	control.offset_top = top_left.y
	control.offset_right = top_left.x + target_size.x
	control.offset_bottom = top_left.y + target_size.y

func _sync_bpm_with_rhythm_manager() -> void:
	var rhythm := get_tree().root.get_node_or_null("RhythmManager")
	if rhythm != null:
		var manager_bpm := float(rhythm.get("bpm"))
		if manager_bpm > 0.0:
			bpm = manager_bpm


func _initial_time_phase() -> StringName:
	var manager := get_tree().root.get_node_or_null("TimePhaseManager")
	if manager != null:
		return StringName(str(manager.get("current_time_phase")))
	return &"past"


func _process(delta: float) -> void:
	if responsive_layout and size != _last_layout_size:
		_apply_responsive_layout()
	var visual_delta := minf(delta, 1.0 / 30.0)
	beat_age += delta
	beat_flash = maxf(0.0, beat_flash - visual_delta * center_flash_decay_rate)
	if _center_hit_timer > 0.0:
		_center_hit_timer -= delta
		if _center_hit_timer <= 0.0:
			center_base.texture = _skin()[&"center_idle"]
	var upcoming := _upcoming_beat_index()
	if upcoming != _last_upcoming_beat:
		_refresh_mover_textures()
	_update_movers()
	if feedback_flash > 0.0:
		feedback_flash = maxf(0.0, feedback_flash - visual_delta * 4.0)
		var feedback_scale := Vector2.ONE * (1.0 + feedback_flash * 0.18)
		judgement_label.scale = feedback_scale
		judgement_art.scale = feedback_scale
	# 满 1 秒才隐藏，倒计时期间不动 modulate/text，避免与脉冲/判定色互相干扰。
	if _judgement_visible_left > 0.0:
		_judgement_visible_left -= visual_delta
		if _judgement_visible_left <= 0.0:
			_judgement_visible_left = 0.0
			judgement_label.visible = false
			judgement_art.visible = false


func _on_beat_ticked(beat_index: int) -> void:
	_last_beat_index = beat_index
	_set_center_flash_profile(false)
	center_flash.texture = _skin()[&"flash_normal"]
	center_flash_color = Color.WHITE
	center_flash_peak = BEAT_TICK_FLASH_PEAK
	beat_flash = 1.0
	beat_age = 0.0
	_refresh_mover_textures()
	_update_movers()


func _on_judgement_made(quality: StringName, offset_ms: float, _beat_index: int) -> void:
	if _time_anchor_feedback_latched:
		# time_anchor_resolved already drove the center emblem, flash and label
		# for this very judgement; don't overwrite the anchor feedback with the
		# plain grade readout.
		_time_anchor_feedback_latched = false
		return
	var color := _judgement_color(quality)
	judgement_label.text = "%s  %s" % [
		str(quality).to_upper(),
		_format_signed_ms(offset_ms / 1000.0),
	]
	judgement_label.modulate = color
	_show_judgement_art(quality)
	feedback_flash = 1.0
	if quality != &"miss":
		_show_center_hit(false)


func _on_chart_event_upcoming(_event: Resource, _time_to_event: float) -> void:
	return


func _on_chart_event_triggered(event: Resource) -> void:
	_set_center_flash_profile(false)
	center_flash.texture = _skin()[&"flash_normal"]
	if StringName(str(event.get("event_type"))) == &"camera_pulse":
		center_flash_color = Color(1.0, 0.84, 0.26, 1.0)
	else:
		center_flash_color = _chart_marker_color(event)
	center_flash_peak = 1.0
	beat_flash = 1.0
	_update_movers()


func _on_time_anchor_scheduled(anchor: Dictionary) -> void:
	_time_anchor_beats[int(anchor.get("beat", 0))] = true
	_refresh_mover_textures()


func _on_time_anchor_resolved(anchor: Dictionary, held: bool, judgement: Dictionary) -> void:
	_time_anchor_beats.erase(int(anchor.get("beat", 0)))
	_refresh_mover_textures()
	# Held anchors resolve inside the judgement_made dispatch (judgement dict is
	# non-empty there); latch so the follow-up grade readout keeps this feedback.
	_time_anchor_feedback_latched = not judgement.is_empty()
	if held:
		_show_center_hit(true)
		judgement_label.text = "ANCHOR HELD"
		judgement_label.modulate = TIME_ANCHOR_HELD_COLOR
		_show_judgement_art(_judgement_from_payload(judgement))
	else:
		_set_center_flash_profile(false)
		center_flash.texture = _skin()[&"flash_special"]
		center_flash_color = TIME_ANCHOR_BROKEN_COLOR
		center_flash_peak = 1.0
		beat_flash = 1.0
		if judgement.is_empty():
			judgement_label.text = ""
			judgement_label.visible = false
			judgement_art.visible = false
			feedback_flash = 0.0
			_judgement_visible_left = 0.0
		else:
			judgement_label.text = "TIME SHIFT!"
			judgement_label.modulate = TIME_ANCHOR_BROKEN_COLOR
			_show_judgement_art(_judgement_from_payload(judgement, &"miss"))
			feedback_flash = 1.0
	if held:
		feedback_flash = 1.0
	_update_movers()


func _show_center_hit(special: bool) -> void:
	# Normal hit: own-phase anchor02 variant + c01 variant flash. Special hit:
	# the cross-phase anchor02 variant + own-phase c02 variant flash.
	var skin := _skin()
	center_base.texture = skin[&"center_hit_special"] if special else skin[&"center_hit_normal"]
	_set_center_flash_profile(true)
	center_flash.texture = skin[&"flash_special"] if special else skin[&"flash_normal"]
	center_flash_color = Color.WHITE
	center_flash_peak = 1.0
	beat_flash = 1.0
	_center_hit_timer = CENTER_HIT_HOLD_SECONDS
	_update_movers()


func _refresh_mover_textures() -> void:
	# The beat the movers are converging toward is the next integer beat; if it
	# is a time anchor the rhythm point itself upgrades to the special texture.
	var skin := _skin()
	var upcoming := _upcoming_beat_index()
	_last_upcoming_beat = upcoming
	var special := _time_anchor_beats.has(upcoming)
	var texture: Texture2D = skin[&"mover_special"] if special else skin[&"mover_normal"]
	mover_size = time_anchor_mover_size if special else normal_mover_size
	if left_mover != null:
		left_mover.texture = texture
	if right_mover != null:
		right_mover.texture = texture
	_update_movers()


func _on_time_phase_changed(_previous: StringName, current: StringName, _reason: StringName) -> void:
	_set_center_flash_profile(false)
	_apply_time_phase_skin(current)
	center_flash_color = Color(0.45, 0.85, 1.0) if current == &"future" else Color(1.0, 0.84, 0.4)
	center_flash_peak = 1.0
	beat_flash = 1.0
	_update_movers()


func _apply_time_phase_skin(time_phase: StringName) -> void:
	_time_phase = time_phase if TRACK_SKINS.has(time_phase) else &"past"
	var skin := _skin()
	track_background.texture = skin[&"background"]
	track_line.visible = false
	track_line.texture = null
	center_base.texture = skin[&"center_idle"]
	center_flash.texture = skin[&"flash_normal"]
	_set_center_flash_profile(false)
	_center_hit_timer = 0.0
	_refresh_mover_textures()


func _skin() -> Dictionary:
	return TRACK_SKINS[_time_phase]


func _on_chart_reset_clear_time_anchor_markers(_chart_id: StringName) -> void:
	_time_anchor_beats.clear()
	_refresh_mover_textures()


func _on_streak_changed(count: int) -> void:
	_streak_count = maxi(0, count)
	_refresh_combo_count()


func _on_attack_buff_changed(stacks: int, max_stacks: int) -> void:
	_attack_buff_max = maxi(1, max_stacks)
	_attack_buff_stacks = clampi(stacks, 0, BUFF_SLOT_COUNT)
	_refresh_attack_buff_display()


func _refresh_combo_count() -> void:
	combo_count_label.text = "combo %d" % _streak_count


func _refresh_attack_buff_display() -> void:
	attack_buff_value_label.text = "ATK x %d%%" % (_attack_buff_stacks * 100)
	for index: int in range(buff_pip_row.get_child_count()):
		var pip := buff_pip_row.get_child(index) as TextureRect
		if pip != null:
			pip.texture = BUFF_ON_TEXTURE if index < _attack_buff_stacks else BUFF_OFF_TEXTURE


func _show_judgement_art(quality: StringName) -> void:
	var normalized := StringName(str(quality).to_lower())
	judgement_art.texture = JUDGEMENT_ARTS.get(normalized, JUDGEMENT_ARTS[&"miss"])
	judgement_art.visible = true
	_judgement_visible_left = JUDGEMENT_VISIBLE_SECONDS
	var feedback_scale := Vector2(1.18, 1.18)
	judgement_label.scale = feedback_scale
	judgement_art.scale = feedback_scale


func _judgement_from_payload(judgement: Dictionary, fallback := &"miss") -> StringName:
	if judgement.has("label"):
		return StringName(str(judgement["label"]).to_lower())
	if judgement.has(&"label"):
		return StringName(str(judgement[&"label"]).to_lower())
	if judgement.has("quality"):
		return StringName(str(judgement["quality"]).to_lower())
	if judgement.has(&"quality"):
		return StringName(str(judgement[&"quality"]).to_lower())
	return fallback


func _update_movers() -> void:
	var progress := _current_beat_progress()
	_set_control_center(left_mover, left_mover_start.lerp(track_center, progress), mover_size)
	_set_control_center(right_mover, right_mover_start.lerp(track_center, progress), mover_size)
	_set_control_center(center_flash, track_center, center_flash_size)
	center_flash.modulate = Color(center_flash_color.r, center_flash_color.g, center_flash_color.b, beat_flash * center_flash_peak)


## Movers follow the musical clock itself so their glide is continuous — the
## old frame-accumulated beat_age plus the beat_flash snap made every beat
## teleport the points to the center and back out. The arrival at the center
## coincides exactly with the beat (progress wraps 1 → 0 on the tick).
func _current_beat_progress() -> float:
	var rhythm := _rhythm_manager_or_null()
	if rhythm != null and rhythm.has_method("get_current_beat_progress") and bool(rhythm.get("running")):
		return clampf(float(rhythm.call("get_current_beat_progress")), 0.0, 1.0)
	var seconds_per_beat := 60.0 / maxf(1.0, bpm)
	return clampf(beat_age / seconds_per_beat, 0.0, 1.0)


## 节奏点正收束的目标拍：直接由音乐时钟推导，而不是等物理帧上报的
## beat_ticked（会晚约一个物理帧），否则拍界处锚点纹理会闪一下普通纹理。
func _upcoming_beat_index() -> int:
	var rhythm := _rhythm_manager_or_null()
	if rhythm != null and bool(rhythm.get("running")) and rhythm.has_method("song_position"):
		var beat_seconds := float(rhythm.get("beat_time"))
		var adjusted := float(rhythm.call("song_position")) + float(rhythm.get("beat_offset"))
		if beat_seconds > 0.0 and adjusted >= 0.0:
			return int(floor(adjusted / beat_seconds)) + 1
	return _last_beat_index + 1


func _rhythm_manager_or_null() -> Node:
	if not is_inside_tree():
		return null
	return get_tree().root.get_node_or_null("RhythmManager")


func _set_center_flash_profile(hit: bool) -> void:
	center_flash_size = hit_center_flash_size if hit else normal_center_flash_size
	center_flash_decay_rate = CENTER_HIT_FLASH_DECAY_RATE if hit else BEAT_FLASH_DECAY_RATE


func _cache_rhythm_track_layout() -> void:
	track_center = _control_center(center_base)
	left_mover_start = _control_center(left_mover)
	right_mover_start = _control_center(right_mover)
	normal_mover_size = left_mover.size if normal_mover_size == Vector2.ZERO else normal_mover_size
	time_anchor_mover_size = normal_mover_size * TIME_ANCHOR_MOVER_SCALE
	mover_size = normal_mover_size
	normal_center_flash_size = center_flash.size if normal_center_flash_size == Vector2.ZERO else normal_center_flash_size
	hit_center_flash_size = normal_center_flash_size * CENTER_HIT_FLASH_SCALE
	center_flash_size = normal_center_flash_size


func _control_center(control: Control) -> Vector2:
	return Vector2(
		(control.offset_left + control.offset_right) * 0.5,
		(control.offset_top + control.offset_bottom) * 0.5
	)


func _set_control_center(control: Control, center: Vector2, size: Vector2) -> void:
	control.offset_left = center.x - size.x * 0.5
	control.offset_top = center.y - size.y * 0.5
	control.offset_right = center.x + size.x * 0.5
	control.offset_bottom = center.y + size.y * 0.5


func _chart_marker_text(event: Resource) -> String:
	match StringName(str(event.get("event_type"))):
		&"show_accent_marker":
			return "ACC"
		&"enemy_action":
			return _enemy_action_marker_text(event)
		&"camera_pulse":
			return "CAM"
	return str(event.get("event_type")).to_upper()


func _chart_marker_color(event: Resource) -> Color:
	match StringName(str(event.get("event_type"))):
		&"show_accent_marker":
			return Color("ffd84a")
		&"enemy_action":
			return Color("ff3355")
		&"camera_pulse":
			return Color("ffffff")
	return Color("00f2ff")


func _enemy_action_marker_text(event: Resource) -> String:
	var action_id := str(event.get("action_id"))
	if action_id.is_empty():
		return "ACT"
	if action_id.begins_with("enemy_"):
		action_id = action_id.substr(6)
	return action_id.replace("_", " ").to_upper()


func _judgement_color(quality: StringName) -> Color:
	match quality:
		&"perfect":
			return Color("00f2ff")
		&"good":
			return Color("ffffff")
		&"bad":
			return Color("ffaa00")
		_:
			return Color("ff0055")


func _chart_marker_position(time_to_event: float) -> Vector2:
	var seconds_per_beat := 60.0 / maxf(1.0, bpm)
	var beat_distance := clampf(time_to_event / seconds_per_beat, 0.0, 4.0)
	var x := track_center.x + beat_distance * 92.0 * _responsive_scale
	return Vector2(x - 33.0 * _responsive_scale, track_center.y + 44.0 * _responsive_scale)


func _format_signed_ms(seconds: float) -> String:
	if is_inf(seconds):
		return "-- ms"
	return "%+.0f ms" % (seconds * 1000.0)


func _event_bus() -> Node:
	var root := get_tree().root
	var bus := root.get_node_or_null("EventBus")
	if bus == null:
		bus = load("res://autoload/event_bus.gd").new()
		bus.name = "EventBus"
		root.add_child(bus)
	return bus