extends SceneTree

const DefinitionRegistryScript := preload("res://scripts/core/definition_registry.gd")
const FacilityCatalogScript := preload("res://scripts/data/facility_catalog.gd")

var _checks := 0
var _failures := 0


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


func _run() -> void:
	_test_catalog_references()
	_test_normal_catalog_lookup()
	_test_expansion_catalog()
	_test_default_registry()
	_test_detailed_definition_schema()
	_test_invalid_detailed_service_is_rejected()
	_test_canonical_added_baselines()
	_test_queries()
	_test_duplicate_detection_is_deterministic()
	_test_missing_path_is_structured()
	if _failures == 0:
		print("PASS: DefinitionRegistry (%d checks)" % _checks)
	else:
		push_error("FAIL: DefinitionRegistry (%d of %d checks failed)" % [_failures, _checks])
	quit(_failures)


func _test_default_registry() -> void:
	var registry = DefinitionRegistryScript.new()
	var report: Dictionary = registry.rebuild()
	_expect(bool(report[&"valid"]), "all baseline definitions pass registry schema validation")
	_expect(int(report[&"source_count"]) == 16, "all sixteen baseline source files are inspected")
	_expect(int(report[&"definition_count"]) == 16, "all sixteen valid definitions are indexed")
	_expect(int(report[&"error_count"]) == 0, "baseline definitions have no fatal schema errors")
	_expect(int(report[&"warning_count"]) == 0, "baseline definitions have no schema warnings")
	var expected_ids: Array[StringName] = [
		&"adult_private_room",
		&"cafeteria",
		&"guest_corridor",
		&"guest_elevator",
		&"kitchen",
		&"massage_room",
		&"public_bath",
		&"reception",
		&"security_station",
		&"service_corridor",
		&"service_elevator",
		&"staff_door",
		&"staff_waiting_room",
		&"standard_room",
		&"tavern",
		&"warehouse",
	]
	_expect(
		registry.get_facility_ids() == expected_ids,
		"all sixteen facility IDs are returned in deterministic lexical order"
	)
	_expect(registry.has_facility(&"reception"), "has_facility finds a known ID")
	_expect(registry.has_facility(&"adult_private_room"), "has_facility finds the underground baseline ID")
	_expect(registry.get_facility(&"missing") == null, "unknown lookup returns null")


func _test_catalog_references() -> void:
	_expect(FacilityCatalogScript.FACILITY_PATHS.size() == 16, "catalog exposes sixteen stable resource references")
	_expect(FacilityCatalogScript.BASELINE_FACILITY_IDS.size() == 16, "catalog exposes sixteen stable baseline IDs")
	var loaded: Array[FacilityDefinition] = FacilityCatalogScript.load_all()
	_expect(loaded.size() == 16, "every catalog resource reference resolves")
	var loaded_ids: Array[StringName] = []
	for index in FacilityCatalogScript.FACILITY_PATHS.size():
		var path: String = FacilityCatalogScript.FACILITY_PATHS[index]
		var expected_id: StringName = FacilityCatalogScript.BASELINE_FACILITY_IDS[index]
		_expect(FileAccess.file_exists(path), "catalog reference %s exists" % path)
		var definition := load(path) as FacilityDefinition
		_expect(definition != null, "catalog reference %s loads as FacilityDefinition" % path)
		if definition != null:
			loaded_ids.append(definition.id)
			_expect(definition.id == expected_id, "catalog reference %s preserves its expected ID" % path)
	_expect(loaded_ids == FacilityCatalogScript.BASELINE_FACILITY_IDS, "catalog loading preserves the design-table order")
	_expect(FacilityCatalogScript.by_id(&"service_elevator") != null, "catalog by_id resolves an added baseline")
	_expect(FacilityCatalogScript.by_id(&"not_a_facility") == null, "catalog by_id rejects an unknown reference")


func _test_normal_catalog_lookup() -> void:
	# Every normal-build registration must also resolve through the public catalog.
	var paths: Array[String] = FacilityCatalogScript.FACILITY_PATHS + FacilityCatalogScript.INFRASTRUCTURE_FACILITY_PATHS + FacilityCatalogScript.RESCUE_FACILITY_PATHS + FacilityCatalogScript.ORIGINAL_FACILITY_PATHS
	for path: String in paths:
		var registered := load(path) as FacilityDefinition
		_expect(registered != null, "normal catalog resource loads: %s" % path)
		if registered != null:
			_expect(FacilityCatalogScript.by_id(registered.id) == registered, "normal registration resolves to identical definition: %s" % registered.id)


func _test_detailed_definition_schema() -> void:
	var registry = DefinitionRegistryScript.new()
	registry.rebuild()
	var reception: FacilityDefinition = registry.get_facility(&"reception")
	var kitchen: FacilityDefinition = registry.get_facility(&"kitchen")
	var restricted: FacilityDefinition = registry.get_facility(&"adult_private_room")
	_expect(reception.has_detailed_profile(), "reception uses the detailed facility schema")
	_expect(reception.default_service_type == &"check_in", "reception declares its default service")
	_expect(reception.service_profiles.size() == 2, "reception defines check-in and check-out profiles")
	_expect(reception.service_profiles[&"check_out"][&"duration_minutes"] == 6, "check-out has an independent duration")
	_expect(kitchen.has_detailed_profile(), "kitchen uses the detailed facility schema")
	_expect(kitchen.service_profiles[&"meal_batch"][&"capacity_units"] == 4, "kitchen service produces a four-unit batch")
	_expect(restricted.has_detailed_profile(), "restricted room uses the detailed facility schema")
	_expect(restricted.opening_schedule == {&"morning": false, &"day": false, &"night": true}, "restricted room is night-only")
	_expect(restricted.service_profiles[&"private_adult_service"][&"need_effects"][&"intimacy"] == -70, "restricted service records need relief")
	_expect(restricted.content_replacement_id == &"massage_room", "restricted service declares a safe replacement")


func _test_invalid_detailed_service_is_rejected() -> void:
	var registry = DefinitionRegistryScript.new()
	var paths: Array[String] = ["res://tests/fixtures/facilities/invalid_service_profile.tres"]
	var report: Dictionary = registry.rebuild_from_paths(paths)
	var errors: Array[Dictionary] = registry.get_fatal_errors()
	_expect(not bool(report[&"valid"]), "an invalid detailed service profile makes the registry invalid")
	_expect(registry.facility_count() == 0, "an invalid detailed facility is not exposed through lookup")
	_expect(errors.size() == 1, "invalid service duration produces one focused issue")
	_expect(errors[0][&"code"] == &"invalid_service_profile_value", "invalid service duration has a stable issue code")
	_expect(errors[0][&"field"] == &"service_profiles", "invalid service issue identifies its owning field")


func _test_expansion_catalog() -> void:
	_expect(FacilityCatalogScript.EXPANSION_FACILITY_IDS.size() == 16, "catalog exposes sixteen optional expansion IDs")
	_expect(FacilityCatalogScript.EXPANSION_FACILITY_PATHS.size() == 16, "catalog exposes sixteen optional expansion resources")
	var loaded: Array[FacilityDefinition] = FacilityCatalogScript.load_expansion()
	_expect(loaded.size() == 16, "every optional expansion resource resolves")
	var loaded_ids: Array[StringName] = []
	for index in FacilityCatalogScript.EXPANSION_FACILITY_PATHS.size():
		var path: String = FacilityCatalogScript.EXPANSION_FACILITY_PATHS[index]
		var expected_id: StringName = FacilityCatalogScript.EXPANSION_FACILITY_IDS[index]
		_expect(FileAccess.file_exists(path), "expansion catalog reference %s exists" % path)
		var definition := load(path) as FacilityDefinition
		_expect(definition != null, "expansion catalog reference %s loads" % path)
		if definition != null:
			loaded_ids.append(definition.id)
			_expect(definition.id == expected_id, "expansion resource preserves %s" % expected_id)
			_expect(definition.is_valid(), "expansion definition %s passes its resource schema" % expected_id)
	_expect(loaded_ids == FacilityCatalogScript.EXPANSION_FACILITY_IDS, "expansion loading preserves design order")
	_expect(FacilityCatalogScript.by_id(&"clinic") != null, "catalog by_id resolves an optional expansion")
	_expect(
		FacilityCatalogScript.by_id(&"vip_private_salon").zone == FacilityDefinition.MapZone.UNDERGROUND,
		"restricted expansion is constrained to the underground zone"
	)
	_expect(
		FacilityCatalogScript.by_id(&"mana_control_room").layer == FacilityDefinition.ViewLayer.BACK,
		"infrastructure expansion is constrained to the BACK layer"
	)


func _test_canonical_added_baselines() -> void:
	var registry = DefinitionRegistryScript.new()
	registry.rebuild()
	var rows: Array = [
		[&"kitchen", 700, 10, Vector2i(4, 2), 1, 3, 20, 15, 0],
		[&"public_bath", 1200, 16, Vector2i(6, 2), 1, 2, 12, 60, 20],
		[&"staff_waiting_room", 400, 6, Vector2i(4, 2), 0, 0, 8, 1, 0],
		[&"security_station", 900, 10, Vector2i(2, 2), 1, 3, 3, 1, 0],
		[&"tavern", 1000, 12, Vector2i(4, 2), 2, 4, 14, 50, 40],
		[&"massage_room", 800, 8, Vector2i(2, 1), 1, 2, 2, 60, 100],
		[&"guest_elevator", 1500, 15, Vector2i(2, 2), 0, 0, 4, 10, 0],
		[&"service_elevator", 2200, 20, Vector2i(3, 2), 0, 0, 8, 5, 0],
		[&"staff_door", 100, 1, Vector2i(1, 1), 0, 0, 1, 1, 0],
		[&"guest_corridor", 20, 0, Vector2i(1, 1), 0, 0, 3, 1, 0],
		[&"service_corridor", 25, 0, Vector2i(1, 1), 0, 0, 2, 1, 0],
		[&"adult_private_room", 1500, 14, Vector2i(2, 1), 1, 1, 2, 90, 250],
	]
	for raw_row: Variant in rows:
		var row := raw_row as Array
		var facility_id: StringName = row[0]
		var definition: FacilityDefinition = registry.get_facility(facility_id)
		_expect(definition != null, "%s canonical baseline is registered" % facility_id)
		if definition == null:
			continue
		_expect(
			definition.construction_cost == {&"gold": row[1], &"materials": row[2]},
			"%s uses canonical Gold and Materials cost" % facility_id
		)
		_expect(definition.footprint == row[3], "%s uses canonical footprint" % facility_id)
		_expect(
			definition.staff_min == row[4] and definition.staff_max == row[5],
			"%s uses canonical Min/Max staffing" % facility_id
		)
		_expect(definition.capacity == row[6], "%s uses canonical capacity" % facility_id)
		_expect(definition.base_service_minutes == row[7], "%s uses canonical duration or one-minute proxy" % facility_id)
		_expect(definition.base_price == row[8], "%s uses canonical direct price" % facility_id)
		_expect(definition.is_valid(), "%s passes the FacilityDefinition schema" % facility_id)

	var kitchen: FacilityDefinition = registry.get_facility(&"kitchen")
	_expect(kitchen.inventory_outputs.get(&"ingredient/basic_meal", 0) == 4, "kitchen models the canonical four-meal production batch")
	var restricted: FacilityDefinition = registry.get_facility(&"adult_private_room")
	_expect(restricted.zone == FacilityDefinition.MapZone.UNDERGROUND, "restricted private room is constrained to the underground zone")
	_expect(&"adult_only" in restricted.tags, "restricted private room carries an explicit adult-only systems guard tag")


func _test_queries() -> void:
	var registry = DefinitionRegistryScript.new()
	registry.rebuild()
	var service_facilities: Array[StringName] = [
		&"adult_private_room", &"massage_room", &"public_bath", &"reception", &"tavern",
	]
	var any_zone: Array[StringName] = [
		&"cafeteria",
		&"guest_corridor",
		&"guest_elevator",
		&"kitchen",
		&"massage_room",
		&"public_bath",
		&"security_station",
		&"service_corridor",
		&"service_elevator",
		&"staff_door",
		&"staff_waiting_room",
		&"standard_room",
		&"tavern",
		&"warehouse",
	]
	var back_facilities: Array[StringName] = [
		&"kitchen",
		&"security_station",
		&"service_corridor",
		&"service_elevator",
		&"staff_door",
		&"staff_waiting_room",
		&"warehouse",
	]
	_expect(
		_ids_of(registry.query_facilities_by_tag(&"service")) == service_facilities,
		"service tag query returns every matching definition in stable order"
	)
	_expect(
		_ids_of(registry.query_facilities_by_zone(FacilityDefinition.MapZone.ANY)) == any_zone,
		"zone query preserves ID order"
	)
	_expect(
		_ids_of(registry.query_facilities_by_zone(FacilityDefinition.MapZone.UNDERGROUND)) == [&"adult_private_room"],
		"underground query isolates its restricted baseline"
	)
	_expect(
		_ids_of(registry.query_facilities_by_layer(FacilityDefinition.ViewLayer.BACK)) == back_facilities,
		"BACK layer query returns all logistics and staff definitions"
	)
	_expect(
		_ids_of(registry.query_facilities_by_tag(&"corridor")) == [&"guest_corridor", &"service_corridor"],
		"corridor tag identifies both route-subslot proxies"
	)
	_expect(
		_ids_of(registry.query_facilities_by_tag(&"vertical_connector")) == [&"guest_elevator", &"service_elevator"],
		"vertical connector tag identifies both elevators"
	)
	_expect(
		_ids_of(registry.query_facilities_by_tag(&"cross_layer_connector")) == [&"staff_door"],
		"cross-layer connector query identifies the staff door proxy"
	)


func _test_duplicate_detection_is_deterministic() -> void:
	var registry = DefinitionRegistryScript.new()
	var duplicate_paths: Array[String] = [
		"res://data/facilities/reception.tres",
		"res://data/facilities/reception.tres",
	]
	var first_report: Dictionary = registry.rebuild_from_paths(duplicate_paths)
	var first_errors: Array[Dictionary] = registry.get_fatal_errors()
	var second_report: Dictionary = registry.rebuild_from_paths(duplicate_paths)
	_expect(not bool(first_report[&"valid"]), "duplicate IDs make the registry invalid")
	_expect(int(first_report[&"error_count"]) == 2, "every duplicate source receives a fatal issue")
	_expect(registry.facility_count() == 0, "duplicate definitions are excluded from lookup")
	_expect(first_errors == registry.get_fatal_errors(), "issue order is deterministic across rebuilds")
	_expect(first_report[&"errors"][0][&"code"] == &"duplicate_id", "duplicate issue has a stable code")
	_expect(int(second_report[&"warning_count"]) == 1, "duplicate source paths produce a warning")


func _test_missing_path_is_structured() -> void:
	var registry = DefinitionRegistryScript.new()
	var paths: Array[String] = ["res://data/facilities/does_not_exist.tres"]
	registry.rebuild_from_paths(paths)
	var errors: Array[Dictionary] = registry.get_fatal_errors()
	_expect(errors.size() == 1, "missing path produces one fatal issue")
	_expect(errors[0][&"severity"] == &"error", "issue carries severity")
	_expect(errors[0][&"code"] == &"resource_not_found", "missing path has a stable code")
	_expect(errors[0][&"field"] == &"resource_path", "issue identifies its field")
	_expect(errors[0][&"resource_path"] == paths[0], "issue identifies its source")


func _ids_of(definitions: Array[FacilityDefinition]) -> Array[StringName]:
	var result: Array[StringName] = []
	for definition in definitions:
		result.append(definition.id)
	return result


func _expect(condition: bool, label: String) -> void:
	_checks += 1
	if condition:
		print("  ✓ %s" % label)
		return
	_failures += 1
	push_error("  ✗ %s" % label)