extends SceneTree

## Asset-free state, ownership, dependency and timing regression for cached WMO scenes.

const CACHE_STATE_SCRIPT := preload(
	"res://src/render/wmo/wmo_scene_resource_cache_state.gd"
)
const CACHE_STATE_PATH := "res://src/render/wmo/wmo_scene_resource_cache_state.gd"
const FINALIZER_PATH := "res://src/render/wmo/wmo_scene_resource_finalizer.gd"
const LOADER_PATH := "res://src/scenes/streaming/streaming_world_loader.gd"


func _initialize() -> void:
	var failures: Array[String] = []
	_verify_invalid_and_request_state(failures)
	_verify_direct_missing_and_exclusivity(failures)
	_verify_validated_scene_completion(failures)
	_verify_failed_request_completion(failures)
	_verify_transient_and_full_clear(failures)
	_verify_detached_sorted_diagnostics(failures)
	_verify_ownership_boundaries(failures)
	var elapsed_milliseconds := _verify_bounded_timing(failures)
	if not failures.is_empty():
		for failure in failures:
			push_error("WMO_SCENE_RESOURCE_CACHE_STATE: %s" % failure)
		quit(1)
		return
	print(
		"WMO_SCENE_RESOURCE_CACHE_STATE PASS cases=11 iterations=100 elapsed_ms=%.3f"
		% elapsed_milliseconds
	)
	quit(0)


func _verify_invalid_and_request_state(failures: Array[String]) -> void:
	var cache_state: RefCounted = CACHE_STATE_SCRIPT.new()
	_expect_false(
		cache_state.call("remember_request", "", "res://cache/a.tscn"),
		"empty normalized path rejected",
		failures
	)
	_expect_false(
		cache_state.call("remember_request", "world/a.wmo", ""),
		"empty cache path rejected",
		failures
	)
	_expect_true(
		cache_state.call("remember_request", "world/a.wmo", "res://cache/a.tscn"),
		"valid request accepted",
		failures
	)
	_expect_true(
		cache_state.call("has_request", "world/a.wmo"),
		"pending request observable",
		failures
	)
	_expect_equal(
		int(cache_state.call("pending_request_count")),
		1,
		"pending request count",
		failures
	)
	_expect_false(
		cache_state.call("remember_request", "world/a.wmo", "res://cache/other.tscn"),
		"duplicate request rejected",
		failures
	)
	var request_snapshot: Dictionary = cache_state.call("request_paths_snapshot")
	_expect_string_equal(
		String(request_snapshot.get("world/a.wmo", "")),
		"res://cache/a.tscn",
		"request cache path preserved",
		failures
	)
	request_snapshot.clear()
	_expect_true(
		cache_state.call("has_request", "world/a.wmo"),
		"request snapshot detached",
		failures
	)


func _verify_direct_missing_and_exclusivity(failures: Array[String]) -> void:
	var cache_state: RefCounted = CACHE_STATE_SCRIPT.new()
	_expect_false(cache_state.call("mark_missing", ""), "empty missing rejected", failures)
	_expect_true(
		cache_state.call("mark_missing", "world/missing.wmo"),
		"direct missing accepted",
		failures
	)
	_expect_true(
		cache_state.call("is_missing", "world/missing.wmo"),
		"direct missing observable",
		failures
	)
	_expect_false(
		cache_state.call("mark_missing", "world/missing.wmo"),
		"duplicate missing rejected",
		failures
	)
	_expect_false(
		cache_state.call(
			"remember_request",
			"world/missing.wmo",
			"res://cache/retry.tscn"
		),
		"missing path rejects request",
		failures
	)


func _verify_validated_scene_completion(failures: Array[String]) -> void:
	var cache_state: RefCounted = CACHE_STATE_SCRIPT.new()
	var validated_scene := PackedScene.new()
	cache_state.call("remember_request", "world/b.wmo", "res://cache/b.tscn")
	_expect_false(
		cache_state.call("complete_request_with_scene", "world/b.wmo", null),
		"null completion rejected",
		failures
	)
	_expect_true(
		cache_state.call("complete_request_with_scene", "world/b.wmo", validated_scene),
		"validated PackedScene completes request",
		failures
	)
	_expect_false(
		cache_state.call("has_request", "world/b.wmo"),
		"successful completion removes request",
		failures
	)
	_expect_true(
		cache_state.call("contains_scene", "world/b.wmo"),
		"successful completion cached",
		failures
	)
	_expect_true(
		cache_state.call("scene_for", "world/b.wmo") == validated_scene,
		"cached PackedScene identity preserved",
		failures
	)
	_expect_false(
		cache_state.call("mark_missing", "world/b.wmo"),
		"cached scene rejects missing state",
		failures
	)


func _verify_failed_request_completion(failures: Array[String]) -> void:
	var cache_state: RefCounted = CACHE_STATE_SCRIPT.new()
	_expect_false(
		cache_state.call("complete_request_as_missing", "world/unknown.wmo"),
		"unknown request completion rejected",
		failures
	)
	cache_state.call("remember_request", "world/failed.wmo", "res://cache/failed.tscn")
	_expect_true(
		cache_state.call("complete_request_as_missing", "world/failed.wmo"),
		"failed request completes as missing",
		failures
	)
	_expect_true(
		cache_state.call("is_missing", "world/failed.wmo"),
		"failed request negative-cached",
		failures
	)
	_expect_false(
		cache_state.call("has_request", "world/failed.wmo"),
		"failed completion removes request",
		failures
	)


func _verify_transient_and_full_clear(failures: Array[String]) -> void:
	var cache_state: RefCounted = CACHE_STATE_SCRIPT.new()
	var retained_scene := PackedScene.new()
	cache_state.call("remember_request", "world/retained.wmo", "res://retained.tscn")
	cache_state.call("complete_request_with_scene", "world/retained.wmo", retained_scene)
	cache_state.call("remember_request", "world/pending.wmo", "res://pending.tscn")
	cache_state.call("mark_missing", "world/missing.wmo")
	cache_state.call("clear_transient_state")
	_expect_true(
		cache_state.call("scene_for", "world/retained.wmo") == retained_scene,
		"transient clear retains PackedScene",
		failures
	)
	_expect_equal(
		int(cache_state.call("pending_request_count")),
		0,
		"transient clear removes requests",
		failures
	)
	_expect_false(
		cache_state.call("is_missing", "world/missing.wmo"),
		"transient clear removes missing state",
		failures
	)
	cache_state.call("clear_all")
	cache_state.call("clear_all")
	_expect_false(
		cache_state.call("contains_scene", "world/retained.wmo"),
		"full clear idempotently releases PackedScene",
		failures
	)


func _verify_detached_sorted_diagnostics(failures: Array[String]) -> void:
	var cache_state: RefCounted = CACHE_STATE_SCRIPT.new()
	cache_state.call("remember_request", "world/z.wmo", "res://z.tscn")
	cache_state.call("remember_request", "world/a.wmo", "res://a.tscn")
	cache_state.call("mark_missing", "world/m.wmo")
	var snapshot: Dictionary = cache_state.call("diagnostic_snapshot")
	_expect_string_array(
		snapshot["request_paths"],
		["world/a.wmo", "world/z.wmo"],
		"request diagnostics sorted",
		failures
	)
	_expect_string_array(
		snapshot["missing_paths"],
		["world/m.wmo"],
		"missing diagnostics",
		failures
	)
	(snapshot["request_paths"] as Array).clear()
	var fresh_snapshot: Dictionary = cache_state.call("diagnostic_snapshot")
	_expect_equal(
		(fresh_snapshot["request_paths"] as Array).size(),
		2,
		"diagnostics detached",
		failures
	)


func _verify_ownership_boundaries(failures: Array[String]) -> void:
	var loader_source := _read_text(LOADER_PATH, failures)
	var cache_state_source := _read_text(CACHE_STATE_PATH, failures)
	var finalizer_source := _read_text(FINALIZER_PATH, failures)
	_expect_true(
		loader_source.contains("WMO_SCENE_RESOURCE_CACHE_STATE_SCRIPT.new()"),
		"loader composes scene cache state",
		failures
	)
	for legacy_field in [
		"var _wmo_scene_resource_cache:",
		"var _wmo_scene_cache_missing:",
		"var _wmo_scene_load_requests:",
	]:
		_expect_false(
			loader_source.contains(legacy_field),
			"loader removes %s" % legacy_field,
			failures
		)
	for loader_owned_token in [
		"ResourceLoader.",
		"FileAccess.",
		"WMO_BUILDER_SCRIPT",
		"instantiate()",
		"Node3D",
		"RID",
		"Mutex",
		"Semaphore",
	]:
		_expect_false(
			cache_state_source.contains(loader_owned_token),
			"scene cache state omits %s dependency" % loader_owned_token,
			failures
		)
	for retained_loader_rule in [
		"wmo_max_runtime_scene_mb",
		"_get_resource_file_size(cache_path)",
	]:
		_expect_true(
			loader_source.contains(retained_loader_rule),
			"loader retains %s" % retained_loader_rule,
			failures
		)
	for finalizer_rule in [
		"scene.instantiate()",
		"is_scene_cache_current",
		"instance.free()",
	]:
		_expect_true(
			finalizer_source.contains(finalizer_rule),
			"finalizer owns %s" % finalizer_rule,
			failures
		)


func _verify_bounded_timing(failures: Array[String]) -> float:
	var cache_state: RefCounted = CACHE_STATE_SCRIPT.new()
	var started_microseconds := Time.get_ticks_usec()
	for iteration in range(100):
		for scene_index in range(256):
			var normalized_path := "world/object_%d.wmo" % scene_index
			if scene_index % 3 == 0:
				cache_state.call("mark_missing", normalized_path)
			else:
				cache_state.call(
					"remember_request",
					normalized_path,
					"res://cache/object_%d.tscn" % scene_index
				)
				if scene_index % 2 == 0:
					cache_state.call(
						"complete_request_with_scene",
						normalized_path,
						PackedScene.new()
					)
				else:
					cache_state.call("complete_request_as_missing", normalized_path)
		cache_state.call("clear_all")
		_expect_equal(
			int(cache_state.call("pending_request_count")),
			0,
			"timing cycle %d clears" % iteration,
			failures
		)
	var elapsed_milliseconds := float(Time.get_ticks_usec() - started_microseconds) / 1000.0
	_expect_true(
		elapsed_milliseconds < 1000.0,
		"100 scene/request cycles remain bounded",
		failures
	)
	return elapsed_milliseconds


func _read_text(path: String, failures: Array[String]) -> String:
	var file := FileAccess.open(path, FileAccess.READ)
	if file == null:
		failures.append("cannot open %s" % path)
		return ""
	return file.get_as_text()


func _expect_equal(
		actual_value: int,
		expected_value: int,
		label: String,
		failures: Array[String]
) -> void:
	if actual_value != expected_value:
		failures.append("%s expected %d, got %d" % [label, expected_value, actual_value])


func _expect_string_equal(
		actual_value: String,
		expected_value: String,
		label: String,
		failures: Array[String]
) -> void:
	if actual_value != expected_value:
		failures.append("%s expected %s, got %s" % [label, expected_value, actual_value])


func _expect_string_array(
		actual_values: Array,
		expected_values: Array,
		label: String,
		failures: Array[String]
) -> void:
	if actual_values != expected_values:
		failures.append("%s expected %s, got %s" % [label, expected_values, actual_values])


func _expect_true(actual_value: bool, label: String, failures: Array[String]) -> void:
	if not actual_value:
		failures.append("%s expected true" % label)


func _expect_false(actual_value: bool, label: String, failures: Array[String]) -> void:
	if actual_value:
		failures.append("%s expected false" % label)