extends SceneTree

const Feedback := preload("res://scripts/ui/ui_audio_feedback.gd")
const AudioTeardown := preload("res://tests/helpers/ui_audio_teardown.gd")
var _checks := 0
var _failures := 0
var _runtime: Variant
var _clock: Variant
var _feedback: Variant
var _cues: Array[StringName] = []
var _case_events: Array[Dictionary] = []
var _case_proofs: Array[Dictionary] = []
var _proof_dir := ""
var _settings_path := "user://tests/audio_feedback_%d/settings.cfg" % OS.get_process_id()


func _initialize() -> void:
	call_deferred(&"_run")


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, 822251)
	_clock.set_paused(true)
	_expect(_runtime.register_command_executor(&"audio_test_ok", _complete), "register real Runtime diagnostic executor")
	_expect(_runtime.register_command_executor(&"audio_test_noop", _noop_complete), "register explicit noop result executor")
	_feedback = Feedback.new()
	_feedback.configure(_runtime, _settings_path, false)
	root.add_child(_feedback)
	_feedback.cue_requested.connect(_record_cue)
	_runtime.command_completed.connect(_record_completion)
	var ui_bus := AudioServer.get_bus_index(Feedback.UI_BUS)
	_expect(ui_bus >= 0 and AudioServer.get_bus_effect_count(ui_bus) == 1 and AudioServer.get_bus_effect(ui_bus, 0) is AudioEffectHardLimiter, "UI cue bus bounds overlapping voices with one limiter")
	_test_ogg_decode()
	var before: Dictionary = _begin_case(&"paused_success_exact_once")
	var result: CommandResult = _feedback.submit_command(&"audio_test_ok", {}, &"player", &"", 0, -1, &"audio-pair")
	_expect(result.is_success() and _cues == [&"success"], "paused emit-before-return has exactly one committed success")
	var with_audio: Dictionary = _runtime.create_snapshot()
	_end_case(&"paused_success_exact_once", before, result)
	_expect(_runtime.restore_snapshot(before), "restore exact before snapshot for paired control")
	_feedback.begin_loaded_epoch()
	_runtime.submit_command(&"audio_test_ok", {}, &"player", &"", 0, -1, &"audio-pair")
	_expect(_record_direct_control(with_audio), "audio shim leaves full snapshot bytes/RNG/IDs identical to direct command")
	var duplicate_before := _begin_case(&"actual_duplicate_refusal")
	var duplicate: CommandResult = _feedback.submit_command(&"audio_test_ok", {}, &"player", &"", 0, -1, &"audio-pair")
	_expect(duplicate.code == CommandResult.Code.DUPLICATE_IDEMPOTENCY_KEY and not duplicate.is_replay, "real repeated submit is a failed duplicate refusal, not a replay DTO")
	_expect(_cues == [&"refusal"], "actual duplicate enqueue refusal sounds exactly once")
	_expect(var_to_bytes(duplicate_before) == var_to_bytes(_runtime.create_snapshot()), "duplicate refusal keeps every Runtime snapshot byte")
	_end_case(&"actual_duplicate_refusal", duplicate_before, duplicate)
	# Existing public Authority executor owns correlation; no fabricated replay flag/ID.
	var replay_payload := {&"incident_id": &"audio.incident.replay", &"incident_type": &"illegal_facility", &"detector_id": &"audio.detector", &"options": {&"severity": 0, &"heat_delta": 0}}
	var incident_setup: CommandResult = _runtime.submit_command(&"report_authority_incident", replay_payload, &"player", &"", 0, -1, &"audio-incident-setup")
	_expect(incident_setup.is_success() and not incident_setup.is_replay, "real public Authority handler establishes diagnostic incident")
	var replay_before := _begin_case(&"actual_public_authority_replay_silent")
	var prior: CommandResult = _runtime.command_queue.get_result_by_idempotency_key(&"audio-pair")
	_expect(prior.is_success() and prior.is_replay, "actual processed queue lookup returns a successful replay copy")
	var replayed: CommandResult = _feedback.submit_command(&"report_authority_incident", replay_payload, &"player", &"", 0, -1, &"audio-replay-diagnostic")
	_expect(replayed.is_success() and replayed.is_replay, "existing public Authority handler returns actual replay flag")
	var stored_replay: CommandResult = _runtime.command_queue.get_processed_result(replayed.command_id)
	_expect(stored_replay.to_dictionary() == replayed.to_dictionary(), "public replay DTO and stored command result have exact correlation")
	_expect(_cues.is_empty(), "actual is_replay completion stays silent during paused emit-before-return")
	_expect(_feedback.get(&"_armed").is_empty() and _feedback.get(&"_active_submissions").is_empty(), "replay retains no pending audio intent after returning")
	var replay_with_audio: Dictionary = _runtime.create_snapshot()
	_end_case(&"actual_public_authority_replay_silent", replay_before, replayed, {&"public_command_type": &"report_authority_incident", &"payload": replay_payload, &"setup_result": incident_setup.to_dictionary(), &"observed_queue_replay_copy": prior.to_dictionary(), &"stored_result": stored_replay.to_dictionary(), &"fabricated_result_fields": 0})
	_expect(_runtime.restore_snapshot(replay_before), "restore whole public replay before snapshot for direct control")
	_feedback.begin_loaded_epoch()
	var direct_replay: CommandResult = _runtime.submit_command(&"report_authority_incident", replay_payload, &"player", &"", 0, -1, &"audio-replay-diagnostic")
	_case_proofs[-1][&"extra"][&"direct_control_result"] = direct_replay.to_dictionary()
	_expect(_record_direct_control(replay_with_audio), "public replay audio shim preserves every gameplay and queue snapshot byte against direct command")
	var noop_before := _begin_case(&"actual_noop_silent")
	var noop: CommandResult = _feedback.submit_command(&"audio_test_noop")
	_expect(noop.is_success() and not noop.is_replay and noop.details.get(&"unchanged", false), "explicit noop is actual successful unchanged result")
	_expect(_cues.is_empty(), "explicit successful unchanged result has no completion audio")
	_end_case(&"actual_noop_silent", noop_before, noop)
	var invalid_before := _begin_case(&"two_actual_enqueue_validation_refusals")
	var invalid_tick: int = _clock.absolute_minute - 1
	var invalid_first: CommandResult = _feedback.submit_command(&"audio_test_ok", {}, &"player", &"", 0, invalid_tick)
	var invalid_second: CommandResult = _feedback.submit_command(&"audio_test_ok", {}, &"player", &"", 0, invalid_tick)
	_expect(invalid_first.code == CommandResult.Code.INVALID_COMMAND and invalid_second.code == CommandResult.Code.INVALID_COMMAND and not invalid_first.is_replay and not invalid_second.is_replay and invalid_first.command_id == invalid_second.command_id, "both invalid execute-at times fail enqueue before consuming the same command ID")
	_expect(_cues == [&"refusal", &"refusal"], "separate real enqueue validation failures each refuse exactly once")
	_expect(var_to_bytes(invalid_before) == var_to_bytes(_runtime.create_snapshot()), "enqueue validation refusals keep every Runtime snapshot byte")
	_end_case(&"two_actual_enqueue_validation_refusals", invalid_before, invalid_second, {&"first_result": invalid_first.to_dictionary(), &"execute_at": invalid_tick, &"issued_tick": _clock.absolute_minute, &"command_type": &"audio_test_ok"})
	var empty_before := _begin_case(&"two_actual_empty_executor_refusals")
	var empty_first: CommandResult = _feedback.submit_command(&"")
	var empty_second: CommandResult = _feedback.submit_command(&"")
	_expect(empty_first.code == CommandResult.Code.INVALID_COMMAND and empty_second.code == CommandResult.Code.INVALID_COMMAND and not empty_first.is_replay and not empty_second.is_replay and empty_second.command_id == empty_first.command_id + 1, "empty command types are real accepted executor failures with separate consumed IDs")
	_expect(_cues == [&"refusal", &"refusal"], "two accepted empty executor failures each refuse exactly once")
	var empty_with_audio: Dictionary = _runtime.create_snapshot()
	_end_case(&"two_actual_empty_executor_refusals", empty_before, empty_second, {&"first_result": empty_first.to_dictionary(), &"command_type": &""})
	_expect(_runtime.restore_snapshot(empty_before), "restore whole empty executor before snapshot for exact direct control")
	_feedback.begin_loaded_epoch()
	var direct_empty_first: CommandResult = _runtime.submit_command(&"")
	var direct_empty_second: CommandResult = _runtime.submit_command(&"")
	_case_proofs[-1][&"extra"][&"direct_control_first_result"] = direct_empty_first.to_dictionary()
	_case_proofs[-1][&"extra"][&"direct_control_second_result"] = direct_empty_second.to_dictionary()
	_expect(_record_direct_control(empty_with_audio), "accepted empty executor failures preserve every full Runtime byte against the same direct submissions")
	_cues.clear()
	var failed: CommandResult = _feedback.submit_command(&"unknown_audio_executor")
	_expect(not failed.is_success() and _cues == [&"refusal"], "paused real executor failure refuses once")
	_runtime.command_completed.emit(failed)
	_expect(_cues == [&"refusal"], "duplicate completed callback does not repeat consumed failure")
	_cues.clear()
	_clock.set_paused(false)
	var queued: CommandResult = _feedback.submit_command(&"audio_test_ok", {}, &"player", &"", 0, -1, &"audio-queued")
	_expect(queued.is_success() and _cues.is_empty(), "queued acceptance has no early success")
	_runtime.submit_command(&"audio_test_ok", {}, &"system", &"", 0, -1, &"audio-internal")
	_clock.advance_minutes(1)
	_expect(_cues == [&"success"], "mixed UI/internal Runtime tick sounds only the armed UI completion")
	_runtime.command_completed.emit(_runtime.command_queue.get_processed_result(queued.command_id))
	_expect(_cues == [&"success"], "repeat tick callback remains silent")
	_cues.clear()
	_feedback.submit_command(&"audio_test_ok", {}, &"player", &"", 0, -1, &"audio-earlier")
	_runtime.submit_command(&"audio_test_ok", {}, &"system", &"", 0, -1, &"audio-other-earlier")
	_clock.set_paused(true)
	_feedback.submit_command(&"audio_test_ok", {}, &"player", &"", 0, -1, &"audio-sync-drain")
	_expect(_cues == [&"success", &"success"], "paused submit drains prior armed UI/internal/current commands with exact correlation")
	_cues.clear()
	_clock.set_paused(false)
	_feedback.submit_command(&"unknown_audio_queued_executor")
	_expect(_cues.is_empty(), "queued executor failure has no premature refusal")
	_clock.advance_minutes(1)
	_expect(_cues == [&"refusal"], "actual queued failure refuses once on domain tick")
	_cues.clear()
	_feedback.submit_command(&"audio_test_ok", {}, &"player", &"", 0, -1, &"audio-restored")
	var pending: Dictionary = _runtime.create_snapshot()
	_expect(_runtime.restore_snapshot(pending), "restore real queued Runtime snapshot")
	_feedback.begin_loaded_epoch()
	_clock.advance_minutes(1)
	_expect(_cues.is_empty(), "loaded pending completion is not a new UI intent")
	_clock.set_paused(true)
	_feedback.update_settings({&"master_volume": 1.0, &"ui_volume": 0.5, &"muted": true})
	_feedback.submit_command(&"audio_test_ok")
	_feedback.update_settings(Feedback.DEFAULT_SETTINGS)
	_expect(_cues.is_empty(), "muted completion consumes intent and unmute never replays history")
	_feedback.bind_runtime(_runtime)
	_feedback.bind_runtime(_runtime)
	_feedback.submit_command(&"audio_test_ok")
	_expect(_cues == [&"success"], "repeated configure connects real Runtime only once")
	_cues.clear()
	var event := EventInstance.new().configure(&"audio_event_A", &"definition", &"definition", [], 0, 360, -1, true, &"audio-test-event")
	event.state = EventInstance.State.WAITING_CHOICE
	_feedback.observe_foreground(event)
	_feedback.observe_foreground(event)
	_feedback.observe_foreground(null)
	_feedback.observe_foreground(event)
	_expect(_cues == [&"notification"], "same foreground refresh and A-none-A notify once")
	_feedback.begin_loaded_epoch(event)
	_feedback.observe_foreground(event)
	_expect(_cues == [&"notification"], "loaded current foreground seeds silently")
	event.event_instance_id = &"audio_event_B"
	_feedback.observe_foreground(event)
	_expect(_cues == [&"notification", &"notification"], "new actual instance ID notifies once")
	_test_settings()
	_write_case_report()
	_runtime.command_completed.disconnect(_record_completion)
	var teardown: Dictionary = await AudioTeardown.free_owner_and_wait(self, _feedback)
	_expect(bool(teardown.get(&"passed", false)) and not bool(teardown.get(&"deadline_reached", true)), "owned audio references release before bounded teardown deadline with whole Runtime unchanged")
	print("UI audio feedback: %d checks, %d failures" % [_checks, _failures])
	quit(_failures)


func _test_ogg_decode() -> void:
	var rows: Array[Dictionary] = []
	var mix_rate := int(AudioServer.get_mix_rate())
	for role: StringName in Feedback.CUES:
		var player: AudioStreamPlayer = _feedback.get(&"_players").get(role)
		_expect(player != null and player.stream is AudioStreamOggVorbis, "Godot loads original Ogg resource " + String(role))
		if player == null or not player.stream is AudioStreamOggVorbis:
			continue
		var stream := player.stream as AudioStreamOggVorbis
		var decoder: AudioStreamPlayback = stream.instantiate_playback()
		decoder.start()
		var frames := 0
		var finite := true
		var peak := 0.0
		while decoder.is_playing() and frames < mix_rate * 2:
			var chunk: PackedVector2Array = decoder.mix_audio(1.0, 512)
			if chunk.is_empty():
				break
			frames += chunk.size()
			for sample: Vector2 in chunk:
				finite = finite and is_finite(sample.x) and is_finite(sample.y)
				peak = maxf(peak, maxf(absf(sample.x), absf(sample.y)))
		var ended := not decoder.is_playing()
		decoder.stop()
		_expect(frames > 0 and finite and peak > 0.0 and peak < 1.0 and ended, "Godot actual finite one-shot decode ends " + String(role))
		_feedback.playback_enabled = true
		_feedback.call("_request_cue", role, {&"diagnostic": true})
		var requested_playing := player.playing
		_expect(requested_playing and not stream.loop, "Godot actual cue requests one-shot player state " + String(role))
		_feedback.begin_loaded_epoch()
		_expect(not player.playing, "loaded epoch stops current cue voice " + String(role))
		rows.append({&"role": role, &"encoded_source_sha256": FileAccess.get_sha256(Feedback.CUES[role]), &"class": stream.get_class(), &"stream_seconds": stream.get_length(), &"mix_rate": mix_rate, &"mixed_frames": frames, &"finite": finite, &"sample_peak": peak, &"one_shot_ended": ended, &"player_playing_after_request": requested_playing, &"player_stopped_on_loaded_epoch": not player.playing})
	_feedback.playback_enabled = false
	_cues.clear()
	var report_path := OS.get_environment("THE_TREE_AUDIO_PROOF_REPORT")
	if report_path.is_empty():
		report_path = "user://tests/audio_feedback_%d/ogg-proof.json" % OS.get_process_id()
	DirAccess.make_dir_recursive_absolute(report_path.get_base_dir())
	var file := FileAccess.open(report_path, FileAccess.WRITE)
	_expect(file != null, "retain actual Godot Ogg decode and request/state proof")
	if file != null:
		file.store_string(JSON.stringify({&"rows": rows, &"Godot_pid": OS.get_process_id(), &"audio_driver": AudioServer.get_driver_name(), &"human_hearing_verified": false, &"native_Windows": &"pending"}, "\t") + "\n")
		file.close()


func _test_settings() -> void:
	_feedback.playback_enabled = true
	_feedback.request_click()
	var click_player: AudioStreamPlayer = _feedback.get(&"_players")[&"click"]
	_expect(click_player.playing, "Godot actual imported Ogg player starts a one-shot")
	var value := {&"master_volume": 0.75, &"ui_volume": 0.25, &"muted": true}
	_expect(_feedback.update_settings(value), "finite routine volume settings accepted")
	_expect(not click_player.playing, "mute stops an existing voice so unmute cannot resume its tail")
	_feedback.playback_enabled = false
	_expect(_feedback.save_settings().get(&"ok", false), "isolated presentation settings save")
	var restored := Feedback.new()
	restored.configure(_runtime, _settings_path, false)
	_expect(restored.settings == value, "presentation settings persist without gameplay save")
	_expect(not restored.update_settings({&"master_volume": NAN, &"ui_volume": 0.5, &"muted": false}), "nonfinite volume rejected")
	_expect(not restored.update_settings({&"master_volume": -0.1, &"ui_volume": 0.5, &"muted": false}), "out-of-range volume rejected")
	var future := ConfigFile.new()
	future.set_value("schema", "version", 999)
	future.set_value("future", "preserve", "original bytes")
	_expect(future.save(_settings_path) == OK, "write isolated future settings specimen")
	var future_sha := FileAccess.get_sha256(_settings_path)
	_expect(not restored.save_settings().get(&"ok", false), "external future settings change blocks stale writer")
	_expect(FileAccess.get_sha256(_settings_path) == future_sha, "blocked stale writer preserves future bytes")
	restored.read_settings()
	_expect(not restored.settings_writable and not restored.save_settings().get(&"ok", false), "fresh reader keeps unknown settings version read-only")
	_expect(FileAccess.get_sha256(_settings_path) == future_sha, "fresh future reader preserves exact original bytes")
	_expect(AudioServer.is_bus_mute(AudioServer.get_bus_index(&"Master")), "routine mute connects to actual AudioServer Master bus")
	_feedback.update_settings(Feedback.DEFAULT_SETTINGS)
	restored.free()


func _complete(command: SimulationCommand) -> CommandResult:
	return CommandResult.succeeded(command.command_id)


func _noop_complete(command: SimulationCommand) -> CommandResult:
	return CommandResult.succeeded(command.command_id, {&"unchanged": true})


func _record_cue(role: StringName, correlation: Dictionary) -> void:
	_cues.append(role)
	_case_events.append({&"kind": &"cue_requested", &"role": role, &"correlation": correlation.duplicate(true), &"audio_state": _audio_state()})


func _record_completion(result: CommandResult) -> void:
	# Connected after Feedback, so the actual paused intent buffer is observable.
	_case_events.append({&"kind": &"command_completed", &"result": result.to_dictionary(), &"audio_state": _audio_state()})


func _dto(value: Variant) -> Variant:
	if value is CommandResult:
		return value.to_dictionary()
	if value is Dictionary:
		var mapped := {}
		for key: Variant in value:
			mapped[key] = _dto(value[key])
		return mapped
	if value is Array:
		var mapped_array: Array = []
		for item: Variant in value:
			mapped_array.append(_dto(item))
		return mapped_array
	return value


func _audio_state() -> Dictionary:
	return {&"epoch": _feedback.get(&"_epoch"), &"nonce": _feedback.get(&"_nonce"), &"armed": _dto(_feedback.get(&"_armed")), &"active_submissions": _dto(_feedback.get(&"_active_submissions"))}


func _begin_case(label: StringName) -> Dictionary:
	_cues.clear()
	_case_events.clear()
	var before: Dictionary = _runtime.create_snapshot()
	_case_events.append({&"kind": &"before_submit", &"case": label, &"audio_state": _audio_state()})
	return before


func _end_case(label: StringName, before: Dictionary, result: CommandResult, extra: Dictionary = {}) -> void:
	if _proof_dir.is_empty():
		var report := OS.get_environment("THE_TREE_AUDIO_COMMAND_PROOF_REPORT")
		_proof_dir = report.get_basename() + "-typed" if not report.is_empty() else "user://tests/audio_feedback_%d/commands-typed" % OS.get_process_id()
	DirAccess.make_dir_recursive_absolute(_proof_dir)
	var after: Dictionary = _runtime.create_snapshot()
	var row := {&"case": label, &"returned_result": result.to_dictionary(), &"cues": _cues.duplicate(), &"events": _case_events.duplicate(true), &"after_audio_state": _audio_state(), &"extra": extra.duplicate(true), &"snapshots": {}}
	for part: StringName in {&"before": before, &"after": after}:
		var path := _proof_dir.path_join("%s-%s.varbytes" % [label, part])
		var bytes := var_to_bytes(before if part == &"before" else after)
		var raw := FileAccess.open(path, FileAccess.WRITE)
		_expect(raw != null, "retain complete typed Runtime snapshot " + String(label) + " " + String(part))
		if raw != null:
			raw.store_buffer(bytes)
			raw.close()
			row[&"snapshots"][part] = {&"path": path, &"bytes": bytes.size(), &"sha256": FileAccess.get_sha256(path), &"full_gameplay_dictionary": true, &"field_deletions": 0}
	_case_proofs.append(row)


func _record_direct_control(with_audio: Dictionary) -> bool:
	var control: Dictionary = _runtime.create_snapshot()
	var matched := var_to_bytes(control) == var_to_bytes(with_audio)
	var row: Dictionary = _case_proofs[-1]
	var path := _proof_dir.path_join("%s-direct_control.varbytes" % row[&"case"])
	var bytes := var_to_bytes(control)
	var raw := FileAccess.open(path, FileAccess.WRITE)
	_expect(raw != null, "retain complete typed same-command direct control " + String(row[&"case"]))
	if raw != null:
		raw.store_buffer(bytes)
		raw.close()
		row[&"snapshots"][&"direct_control"] = {&"path": path, &"bytes": bytes.size(), &"sha256": FileAccess.get_sha256(path), &"full_gameplay_dictionary": true, &"field_deletions": 0}
	row[&"extra"][&"direct_control_pair_verified"] = matched
	return matched


func _write_case_report() -> void:
	var path := OS.get_environment("THE_TREE_AUDIO_COMMAND_PROOF_REPORT")
	if path.is_empty():
		path = "user://tests/audio_feedback_%d/commands.json" % OS.get_process_id()
	DirAccess.make_dir_recursive_absolute(path.get_base_dir())
	var file := FileAccess.open(path, FileAccess.WRITE)
	_expect(file != null, "retain actual result DTO, paused intent buffers and whole typed snapshot evidence")
	if file != null:
		file.store_string(JSON.stringify({&"cases": _case_proofs, &"Godot_pid": OS.get_process_id(), &"buffer_CommandResult_objects_recorded_as_full_DTO": true, &"gameplay_snapshot_field_deletions": 0, &"source_fallback": false, &"formal_P22_P25_acceptance": false}, "\t") + "\n")
		file.close()


func _expect(condition: bool, label: String) -> void:
	_checks += 1
	if not condition:
		_failures += 1
		push_error(label)