TheTree_mock/scripts/facility/facility_service.gd

class_name FacilityService
extends RefCounted

signal instance_registered(instance: FacilityInstance)
signal instance_unregistered(instance_id: StringName)
signal facility_state_changed(instance_id: StringName, old_state: int, new_state: int, reasons: Array[StringName])
signal request_enqueued(request: ServiceRequest)
signal request_left_queue(request_id: StringName, reason: StringName)
signal service_started(service: ServiceInstance)
signal service_interrupted(service: ServiceInstance, reason: StringName)
signal service_completed(service: ServiceInstance)
signal service_failed(service: ServiceInstance, reason: StringName)

const FacilityInstanceType = preload("res://scripts/facility/facility_instance.gd")
const ServiceRequestType = preload("res://scripts/facility/service_request.gd")
const ServiceInstanceType = preload("res://scripts/facility/service_instance.gd")
const CommandResultType = preload("res://scripts/core/command_result.gd")

const SNAPSHOT_VERSION := 1
const STAFF_REPLACEMENT_GRACE_MINUTES := 5

const INTERRUPTION_PLAYER_CLOSED := &"PLAYER_CLOSED"
const INTERRUPTION_NO_POWER := &"NO_POWER"
const INTERRUPTION_MANA_STOP := &"MANA_STOP"
const INTERRUPTION_STAFF_UNAVAILABLE := &"STAFF_UNAVAILABLE"
const INTERRUPTION_EMERGENCY := &"EMERGENCY"
const INTERRUPTION_FIRE := &"FIRE"
const INTERRUPTION_RIOT := &"RIOT"
const INTERRUPTION_GUEST_LEFT := &"GUEST_LEFT"
const INTERRUPTION_BROKEN := &"BROKEN"

var current_minute := 0
var last_error := ""

var _instances: Dictionary = {}
var _requests: Dictionary = {}
var _known_instance_ids: Dictionary = {}
var _known_request_ids: Dictionary = {}
var _known_service_ids: Dictionary = {}
var _service_history: Dictionary = {}
var _next_service_sequence := 1
var _start_validator := Callable()
var _completion_callback := Callable()


func configure_callbacks(
	start_validator: Callable = Callable(),
	completion_callback: Callable = Callable()
) -> FacilityService:
	_start_validator = start_validator
	_completion_callback = completion_callback
	return self


func set_start_validator(callback: Callable) -> void:
	_start_validator = callback


func set_completion_callback(callback: Callable) -> void:
	_completion_callback = callback


func register_instance(instance: Variant) -> CommandResult:
	if instance == null or not instance is FacilityInstance:
		return _invalid("Facility instance is missing or has an invalid type.")
	var facility: FacilityInstance = instance
	if not facility.is_valid():
		return _invalid("Facility instance is invalid.", {&"instance_id": facility.instance_id})
	if _known_instance_ids.has(facility.instance_id):
		return _duplicate("Facility instance", facility.instance_id)
	if not facility.queue_entries.is_empty() or not facility.active_services.is_empty():
		return _invalid(
			"A new facility must be registered before it owns requests or services.",
			{&"instance_id": facility.instance_id}
		)
	_instances[facility.instance_id] = facility
	_known_instance_ids[facility.instance_id] = true
	facility.evaluate_state(current_minute)
	instance_registered.emit(facility)
	last_error = ""
	return _success({&"instance_id": facility.instance_id})


func create_instance(configuration: Dictionary) -> CommandResult:
	var instance := FacilityInstanceType.new().configure(
		StringName(_value(configuration, &"instance_id", &"")),
		StringName(_value(configuration, &"definition_id", &"")),
		configuration
	)
	var result := register_instance(instance)
	if result.is_success():
		result.details[&"instance"] = instance
	return result


func has_instance(instance_id: StringName) -> bool:
	return _instances.has(instance_id)


func get_instance(instance_id: StringName) -> FacilityInstance:
	return _instances.get(instance_id) as FacilityInstance


func get_facility(instance_id: StringName) -> FacilityInstance:
	return get_instance(instance_id)


func get_instances() -> Array[FacilityInstance]:
	var result: Array[FacilityInstance] = []
	for instance_id: StringName in _sorted_keys(_instances):
		result.append(_instances[instance_id])
	return result


func unregister_instance(instance_id: StringName) -> CommandResult:
	var instance := get_instance(instance_id)
	if instance == null:
		return _not_found("Facility instance", instance_id)
	if not instance.queue_entries.is_empty() or not instance.active_services.is_empty():
		return _invalid(
			"A facility with queued or active services cannot be unregistered.",
			{&"instance_id": instance_id}
		)
	_instances.erase(instance_id)
	instance_unregistered.emit(instance_id)
	last_error = ""
	return _success({&"instance_id": instance_id})


func set_operational_status(
	instance_id: StringName,
	conditions: Dictionary,
	absolute_minute: int = -1
) -> CommandResult:
	var instance := get_instance(instance_id)
	if instance == null:
		return _not_found("Facility instance", instance_id)
	var minute := _resolve_minute(absolute_minute)
	var old_state := instance.state
	instance.set_operational_conditions(conditions, minute)
	_emit_state_change(instance, old_state)
	last_error = ""
	return _success({
		&"instance_id": instance_id,
		&"state": FacilityInstanceType.State.keys()[instance.state],
		&"state_reasons": instance.state_reasons.duplicate(),
	})


func set_opening_hours(
	instance_id: StringName,
	open_minute_of_day: int,
	close_minute_of_day: int,
	absolute_minute: int = -1
) -> CommandResult:
	var instance := get_instance(instance_id)
	if instance == null:
		return _not_found("Facility instance", instance_id)
	if not instance.set_opening_hours(open_minute_of_day, close_minute_of_day):
		return _invalid("Opening hours must be valid minute-of-day values.")
	var old_state := instance.state
	instance.evaluate_state(_resolve_minute(absolute_minute))
	_emit_state_change(instance, old_state)
	last_error = ""
	return _success({&"instance_id": instance_id})


func set_policy(
	instance_id: StringName,
	patch: Dictionary,
	effective_at: int = -1
) -> CommandResult:
	var instance := get_instance(instance_id)
	if instance == null:
		return _not_found("Facility instance", instance_id)
	if patch.is_empty():
		return _invalid("Policy patch cannot be empty.")
	if effective_at >= 0 and effective_at > current_minute:
		instance.schedule_policy_patch(patch, effective_at)
		last_error = ""
		return _success({
			&"instance_id": instance_id,
			&"pending_revision": instance.policy_pending_revision,
			&"effective_at": effective_at,
		})
	var changed := instance.apply_policy_patch(patch)
	last_error = ""
	return _success({
		&"instance_id": instance_id,
		&"policy_revision": instance.policy_revision,
		&"changed": changed,
	})


func create_request(
	request_id: StringName,
	facility_id: StringName,
	guest_ids: Array[StringName],
	service_type: StringName,
	created_at: int,
	options: Dictionary = {}
) -> ServiceRequest:
	var instance := get_instance(facility_id)
	if instance == null:
		return null
	var quotation := options.duplicate(true)
	if not _has_value(quotation, &"quoted_price"):
		quotation[&"quoted_price"] = instance.base_price
	if not _has_value(quotation, &"expected_quality"):
		quotation[&"expected_quality"] = instance.base_quality
	if not _has_value(quotation, &"service_minutes"):
		quotation[&"service_minutes"] = instance.base_service_minutes
	quotation[&"policy_snapshot"] = instance.policy_current.duplicate(true)
	quotation[&"policy_revision"] = instance.policy_revision
	return ServiceRequestType.new().configure(
		request_id,
		facility_id,
		guest_ids,
		service_type,
		created_at,
		quotation
	)


func enqueue_request(request: Variant, absolute_minute: int = -1) -> CommandResult:
	if request == null or not request is ServiceRequest:
		return _invalid("Service request is missing or has an invalid type.")
	var queued_request: ServiceRequest = request
	if not queued_request.is_valid():
		return _invalid("Service request is invalid.")
	if _known_request_ids.has(queued_request.request_id):
		return _duplicate("Service request", queued_request.request_id)
	var instance := get_instance(queued_request.facility_id)
	if instance == null:
		return _not_found("Facility instance", queued_request.facility_id)
	if not instance.has_queue_space():
		return _invalid(
			"Facility queue is full.",
			{&"instance_id": instance.instance_id, &"queue_capacity": instance.queue_capacity}
		)
	var minute := _resolve_minute(absolute_minute)
	queued_request.enqueued_at = minute
	_requests[queued_request.request_id] = queued_request
	_known_request_ids[queued_request.request_id] = true
	instance.queue_entries.append(queued_request.request_id)
	_sort_queue(instance)
	queued_request.expected_wait = _estimate_wait_before(instance, queued_request.request_id)
	_increment_stat(instance.statistics_today, &"requests_enqueued")
	_increment_stat(instance.lifetime_statistics, &"requests_enqueued")
	request_enqueued.emit(queued_request)
	last_error = ""
	return _success({
		&"request_id": queued_request.request_id,
		&"expected_wait": queued_request.expected_wait,
		&"queue_position": instance.queue_entries.find(queued_request.request_id),
	})


func submit_request(request: Variant, absolute_minute: int = -1) -> CommandResult:
	return enqueue_request(request, absolute_minute)


func get_request(request_id: StringName) -> ServiceRequest:
	return _requests.get(request_id) as ServiceRequest


func get_queue(instance_id: StringName) -> Array[ServiceRequest]:
	var queued: Array[ServiceRequest] = []
	var instance := get_instance(instance_id)
	if instance == null:
		return queued
	for request_id: StringName in instance.queue_entries:
		var request := get_request(request_id)
		if request != null:
			queued.append(request)
	return queued


func peek_next_request(instance_id: StringName) -> ServiceRequest:
	var instance := get_instance(instance_id)
	if instance == null or instance.queue_entries.is_empty():
		return null
	return get_request(instance.queue_entries[0])


func leave_queue(
	instance_id: StringName,
	request_id: StringName,
	reason: StringName = &"GUEST_LEFT"
) -> CommandResult:
	var instance := get_instance(instance_id)
	if instance == null:
		return _not_found("Facility instance", instance_id)
	var queue_index := instance.queue_entries.find(request_id)
	if queue_index < 0:
		return _not_found("Queued service request", request_id)
	instance.queue_entries.remove_at(queue_index)
	_requests.erase(request_id)
	_increment_stat(instance.statistics_today, &"queue_departures")
	_increment_stat(instance.lifetime_statistics, &"queue_departures")
	request_left_queue.emit(request_id, reason)
	last_error = ""
	return _success({&"request_id": request_id, &"reason": reason})


func cancel_request(request_id: StringName, reason: StringName = &"GUEST_LEFT") -> CommandResult:
	for instance_id: StringName in _sorted_keys(_instances):
		var instance: FacilityInstance = _instances[instance_id]
		if instance.queue_entries.has(request_id):
			return leave_queue(instance_id, request_id, reason)
	return _not_found("Queued service request", request_id)


func start_next_service(
	instance_id: StringName,
	absolute_minute: int = -1,
	validator: Callable = Callable()
) -> CommandResult:
	var instance := get_instance(instance_id)
	if instance == null:
		return _not_found("Facility instance", instance_id)
	var minute := _resolve_minute(absolute_minute)
	instance.apply_pending_policy(minute)
	var old_state := instance.state
	instance.evaluate_state(minute)
	_emit_state_change(instance, old_state)
	if not instance.can_start_service(minute):
		return _invalid(
			"Facility cannot start a service in its current state.",
			{
				&"instance_id": instance_id,
				&"state": FacilityInstanceType.State.keys()[instance.state],
				&"reasons": instance.state_reasons.duplicate(),
			}
		)
	_cleanup_missing_queue_requests(instance)
	if instance.queue_entries.is_empty():
		return _not_found("Queued service request", &"")
	var request := get_request(instance.queue_entries[0])
	if request == null:
		return _invalid("The next queue entry is corrupt.")
	var effective_validator := validator if validator.is_valid() else _start_validator
	var callback_failure := _run_boundary_callback(
		effective_validator,
		[request, instance, minute],
		"Service start validation failed.",
		CommandResultType.Code.VALIDATION_FAILED
	)
	if callback_failure != null:
		callback_failure.details[&"request_id"] = request.request_id
		callback_failure.details[&"instance_id"] = instance_id
		return callback_failure

	var service_id := _next_service_id()
	var service := ServiceInstanceType.new().configure(
		service_id,
		request.request_id,
		instance_id,
		minute,
		request.service_minutes if request.service_minutes > 0 else instance.base_service_minutes,
		request.guest_ids,
		instance.active_staff_ids,
		{
			&"quality_snapshot": request.expected_quality,
			&"price_snapshot": request.quoted_price,
			&"policy_snapshot": request.policy_snapshot,
			&"inventory_reservations": request.reserved_inventory_ids,
		}
	)
	instance.queue_entries.remove_at(0)
	instance.active_services[service_id] = service
	_known_service_ids[service_id] = true
	_increment_stat(instance.statistics_today, &"services_started")
	_increment_stat(instance.lifetime_statistics, &"services_started")
	service_started.emit(service)
	last_error = ""
	return _success({
		&"instance_id": instance_id,
		&"request_id": request.request_id,
		&"service_id": service_id,
		&"slot": instance.capacity - instance.available_slots() - 1,
	})


func fill_available_slots(
	instance_id: StringName,
	absolute_minute: int = -1,
	validator: Callable = Callable()
) -> Array[CommandResult]:
	var results: Array[CommandResult] = []
	var instance := get_instance(instance_id)
	if instance == null:
		results.append(_not_found("Facility instance", instance_id))
		return results
	var minute := _resolve_minute(absolute_minute)
	while instance.available_slots() > 0 and not instance.queue_entries.is_empty():
		var result := start_next_service(instance_id, minute, validator)
		results.append(result)
		if not result.is_success():
			break
	return results


func advance_one_minute(absolute_minute: int = -1) -> Array[CommandResult]:
	if absolute_minute < 0:
		current_minute += 1
	elif absolute_minute < current_minute:
		return [_invalid("FacilityService cannot advance backwards in time.")]
	else:
		current_minute = absolute_minute
	var results: Array[CommandResult] = []
	for instance_id: StringName in _sorted_keys(_instances):
		var instance: FacilityInstance = _instances[instance_id]
		instance.apply_pending_policy(current_minute)
		var old_state := instance.state
		instance.evaluate_state(current_minute)
		_emit_state_change(instance, old_state)
		var active_ids := _sorted_keys(instance.active_services)
		for service_id: StringName in active_ids:
			if not instance.active_services.has(service_id):
				continue
			var service: ServiceInstance = instance.active_services[service_id]
			var preparation := _prepare_service_for_tick(instance, service)
			if preparation != null:
				results.append(preparation)
			if not instance.active_services.has(service_id):
				continue
			if service.state != ServiceInstanceType.State.ACTIVE:
				continue
			var ready_to_complete := service.elapsed_minutes >= service.duration_minutes
			if not ready_to_complete:
				ready_to_complete = service.advance_one_minute()
			if ready_to_complete:
				results.append(_complete_service(instance, service))
		var starts := fill_available_slots(instance_id, current_minute)
		results.append_array(starts)
	last_error = ""
	return results


func interrupt_service(
	service_id: StringName,
	reason: StringName,
	absolute_minute: int = -1
) -> CommandResult:
	var located := _find_active_service(service_id)
	if located.is_empty():
		return _not_found("Active service", service_id)
	var instance: FacilityInstance = located[&"instance"]
	var service: ServiceInstance = located[&"service"]
	var minute := _resolve_minute(absolute_minute)
	match reason:
		INTERRUPTION_PLAYER_CLOSED:
			return _success({&"service_id": service_id, &"continues": true})
		INTERRUPTION_NO_POWER, INTERRUPTION_MANA_STOP:
			service.pause(INTERRUPTION_NO_POWER, minute)
		INTERRUPTION_STAFF_UNAVAILABLE:
			service.wait_for_staff(reason, minute, STAFF_REPLACEMENT_GRACE_MINUTES)
		INTERRUPTION_BROKEN, INTERRUPTION_EMERGENCY, INTERRUPTION_FIRE, INTERRUPTION_RIOT, INTERRUPTION_GUEST_LEFT:
			_fail_service(instance, service, reason, minute)
			return _success({&"service_id": service_id, &"failed": true, &"reason": reason})
		_:
			return _invalid("Unknown service interruption reason.", {&"reason": reason})
	service_interrupted.emit(service, reason)
	last_error = ""
	return _success({
		&"service_id": service_id,
		&"state": ServiceInstanceType.State.keys()[service.state],
		&"reason": reason,
	})


func resume_service(service_id: StringName) -> CommandResult:
	var located := _find_active_service(service_id)
	if located.is_empty():
		return _not_found("Active service", service_id)
	var service: ServiceInstance = located[&"service"]
	if not service.resume():
		return _invalid("Only an interrupted service can resume.")
	last_error = ""
	return _success({&"service_id": service_id})


func replace_service_staff(service_id: StringName, staff_ids: Array[StringName]) -> CommandResult:
	var located := _find_active_service(service_id)
	if located.is_empty():
		return _not_found("Active service", service_id)
	if staff_ids.is_empty():
		return _invalid("Replacement staff list cannot be empty.")
	var service: ServiceInstance = located[&"service"]
	service.staff_ids.assign(staff_ids)
	if service.state == ServiceInstanceType.State.WAITING_FOR_STAFF:
		service.resume()
	last_error = ""
	return _success({&"service_id": service_id})


func get_service(service_id: StringName) -> ServiceInstance:
	var located := _find_active_service(service_id)
	if not located.is_empty():
		return located[&"service"] as ServiceInstance
	return _service_history.get(service_id) as ServiceInstance


func get_active_services(instance_id: StringName) -> Array[ServiceInstance]:
	var services: Array[ServiceInstance] = []
	var instance := get_instance(instance_id)
	if instance == null:
		return services
	for service_id: StringName in _sorted_keys(instance.active_services):
		services.append(instance.active_services[service_id])
	return services


func create_snapshot() -> Dictionary:
	var saved_instances: Array[Dictionary] = []
	for instance_id: StringName in _sorted_keys(_instances):
		var instance: FacilityInstance = _instances[instance_id]
		saved_instances.append(instance.create_snapshot())
	var saved_requests: Array[Dictionary] = []
	for request_id: StringName in _sorted_keys(_requests):
		var request: ServiceRequest = _requests[request_id]
		saved_requests.append(request.create_snapshot())
	var saved_history: Array[Dictionary] = []
	for service_id: StringName in _sorted_keys(_service_history):
		var service: ServiceInstance = _service_history[service_id]
		saved_history.append(service.create_snapshot())
	return {
		&"schema_version": SNAPSHOT_VERSION,
		&"current_minute": current_minute,
		&"next_service_sequence": _next_service_sequence,
		&"known_instance_ids": _keys_to_strings(_known_instance_ids),
		&"known_request_ids": _keys_to_strings(_known_request_ids),
		&"known_service_ids": _keys_to_strings(_known_service_ids),
		&"instances": saved_instances,
		&"requests": saved_requests,
		&"service_history": saved_history,
	}


func restore_snapshot(snapshot: Dictionary) -> bool:
	if int(_value(snapshot, &"schema_version", 0)) != SNAPSHOT_VERSION:
		last_error = "Unsupported FacilityService snapshot version."
		return false
	var array_fields := [
		&"known_instance_ids", &"known_request_ids", &"known_service_ids",
		&"instances", &"requests", &"service_history",
	]
	for field: StringName in array_fields:
		if not _value(snapshot, field, null) is Array:
			last_error = "FacilityService snapshot field '%s' must be an Array." % field
			return false

	var restored_instances: Dictionary = {}
	for saved_instance: Variant in _value(snapshot, &"instances", []):
		if not saved_instance is Dictionary:
			last_error = "Facility snapshot entry must be a Dictionary."
			return false
		var instance := FacilityInstanceType.from_snapshot(saved_instance)
		if instance == null or restored_instances.has(instance.instance_id):
			last_error = "Facility snapshot contains an invalid or duplicate instance."
			return false
		restored_instances[instance.instance_id] = instance

	var restored_requests: Dictionary = {}
	for saved_request: Variant in _value(snapshot, &"requests", []):
		if not saved_request is Dictionary:
			last_error = "Request snapshot entry must be a Dictionary."
			return false
		var request := ServiceRequestType.from_snapshot(saved_request)
		if request == null or restored_requests.has(request.request_id):
			last_error = "Facility snapshot contains an invalid or duplicate request."
			return false
		restored_requests[request.request_id] = request

	var restored_history: Dictionary = {}
	for saved_service: Variant in _value(snapshot, &"service_history", []):
		if not saved_service is Dictionary:
			last_error = "Service history entry must be a Dictionary."
			return false
		var service := ServiceInstanceType.from_snapshot(saved_service)
		if service == null or not service.is_terminal() or restored_history.has(service.service_id):
			last_error = "Facility snapshot contains invalid service history."
			return false
		restored_history[service.service_id] = service

	var restored_known_instances: Variant = _id_set(_value(snapshot, &"known_instance_ids", []))
	var restored_known_requests: Variant = _id_set(_value(snapshot, &"known_request_ids", []))
	var restored_known_services: Variant = _id_set(_value(snapshot, &"known_service_ids", []))
	if restored_known_instances == null or restored_known_requests == null or restored_known_services == null:
		last_error = "Known ID lists contain an empty or duplicate ID."
		return false
	if not _validate_restored_graph(
		restored_instances,
		restored_requests,
		restored_history,
		restored_known_instances,
		restored_known_requests,
		restored_known_services
	):
		return false

	var restored_next_sequence := int(_value(snapshot, &"next_service_sequence", 0))
	var restored_minute := int(_value(snapshot, &"current_minute", -1))
	if restored_next_sequence < 1 or restored_minute < 0:
		last_error = "FacilityService counters are invalid."
		return false

	# Commit only after every object and cross-reference has validated.
	_instances = restored_instances
	_requests = restored_requests
	_service_history = restored_history
	_known_instance_ids = restored_known_instances
	_known_request_ids = restored_known_requests
	_known_service_ids = restored_known_services
	_next_service_sequence = restored_next_sequence
	current_minute = restored_minute
	last_error = ""
	return true


func _validate_restored_graph(
	instances: Dictionary,
	requests: Dictionary,
	history: Dictionary,
	known_instances: Dictionary,
	known_requests: Dictionary,
	known_services: Dictionary
) -> bool:
	var referenced_requests: Dictionary = {}
	var active_service_ids: Dictionary = {}
	for instance_id: StringName in _sorted_keys(instances):
		var instance: FacilityInstance = instances[instance_id]
		if not known_instances.has(instance_id):
			last_error = "Active facility ID is absent from known IDs."
			return false
		for request_id: StringName in instance.queue_entries:
			if referenced_requests.has(request_id) or not requests.has(request_id):
				last_error = "Queue contains a duplicate or missing request."
				return false
			var request: ServiceRequest = requests[request_id]
			if request.facility_id != instance_id:
				last_error = "Queued request targets another facility."
				return false
			referenced_requests[request_id] = true
		for service_id: StringName in _sorted_keys(instance.active_services):
			var service: ServiceInstance = instance.active_services[service_id]
			if active_service_ids.has(service_id) or history.has(service_id):
				last_error = "Service ID occurs more than once."
				return false
			if not known_services.has(service_id) or not requests.has(service.request_id):
				last_error = "Active service has a missing known ID or request."
				return false
			if referenced_requests.has(service.request_id):
				last_error = "Request is referenced by multiple queue/service entries."
				return false
			var request: ServiceRequest = requests[service.request_id]
			if request.facility_id != instance_id:
				last_error = "Active service request targets another facility."
				return false
			referenced_requests[service.request_id] = true
			active_service_ids[service_id] = true
	for request_id: StringName in _sorted_keys(requests):
		if not known_requests.has(request_id) or not referenced_requests.has(request_id):
			last_error = "Live request is orphaned or absent from known IDs."
			return false
	for service_id: StringName in _sorted_keys(history):
		if not known_services.has(service_id):
			last_error = "Historical service is absent from known IDs."
			return false
	return true


func _prepare_service_for_tick(
	instance: FacilityInstance,
	service: ServiceInstance
) -> CommandResult:
	if instance.state == FacilityInstanceType.State.BROKEN:
		_fail_service(instance, service, INTERRUPTION_BROKEN, current_minute)
		return _success({&"service_id": service.service_id, &"failed": true})
	if not instance.power_available:
		if service.state == ServiceInstanceType.State.ACTIVE:
			service.pause(INTERRUPTION_NO_POWER, current_minute)
			service_interrupted.emit(service, INTERRUPTION_NO_POWER)
		return null
	if service.state == ServiceInstanceType.State.PAUSED \
		and service.interruption_reason == INTERRUPTION_NO_POWER:
		service.resume()
	var has_required_staff := instance.active_staff_ids.size() >= instance.staff_min
	if not has_required_staff:
		if service.state in [ServiceInstanceType.State.ACTIVE, ServiceInstanceType.State.PAUSED]:
			service.wait_for_staff(
				INTERRUPTION_STAFF_UNAVAILABLE,
				current_minute,
				STAFF_REPLACEMENT_GRACE_MINUTES
			)
			service_interrupted.emit(service, INTERRUPTION_STAFF_UNAVAILABLE)
	elif instance.staff_min > 0 \
		and service.state == ServiceInstanceType.State.WAITING_FOR_STAFF \
		and service.interruption_reason == INTERRUPTION_STAFF_UNAVAILABLE:
		service.resume()
	if service.state == ServiceInstanceType.State.WAITING_FOR_STAFF:
		if service.staff_grace_deadline >= 0 and current_minute >= service.staff_grace_deadline:
			_fail_service(instance, service, INTERRUPTION_STAFF_UNAVAILABLE, current_minute)
			return _success({&"service_id": service.service_id, &"failed": true})
	return null


func _complete_service(
	instance: FacilityInstance,
	service: ServiceInstance,
	callback: Callable = Callable()
) -> CommandResult:
	var request := get_request(service.request_id)
	if request == null:
		_fail_service(instance, service, &"MISSING_REQUEST", current_minute)
		return _invalid(
			"Active service lost its request and was failed safely.",
			{&"service_id": service.service_id}
		)
	var effective_callback := callback if callback.is_valid() else _completion_callback
	var callback_failure := _run_boundary_callback(
		effective_callback,
		[service, request, instance, current_minute],
		"Service completion transaction failed.",
		CommandResultType.Code.TRANSACTION_APPLY_FAILED
	)
	if callback_failure != null:
		callback_failure.details[&"service_id"] = service.service_id
		callback_failure.details[&"request_id"] = request.request_id
		return callback_failure
	service.mark_completed(current_minute)
	instance.active_services.erase(service.service_id)
	_requests.erase(request.request_id)
	_service_history[service.service_id] = service
	_increment_stat(instance.statistics_today, &"services_completed")
	_increment_stat(instance.lifetime_statistics, &"services_completed")
	service_completed.emit(service)
	return _success({
		&"instance_id": instance.instance_id,
		&"request_id": request.request_id,
		&"service_id": service.service_id,
		&"completed": true,
	})


func _fail_service(
	instance: FacilityInstance,
	service: ServiceInstance,
	reason: StringName,
	absolute_minute: int
) -> void:
	service.mark_failed(reason, absolute_minute)
	instance.active_services.erase(service.service_id)
	_requests.erase(service.request_id)
	_service_history[service.service_id] = service
	_increment_stat(instance.statistics_today, &"services_failed")
	_increment_stat(instance.lifetime_statistics, &"services_failed")
	service_failed.emit(service, reason)


func _run_boundary_callback(
	callback: Callable,
	arguments: Array,
	fallback_message: String,
	failure_code: CommandResult.Code
) -> CommandResult:
	if not callback.is_valid():
		return null
	var argument_count := callback.get_argument_count()
	var effective_arguments := arguments
	if argument_count >= 0 and argument_count < arguments.size():
		effective_arguments = arguments.slice(0, argument_count)
	var returned: Variant = callback.callv(effective_arguments)
	if returned == null or (returned is bool and returned):
		return null
	if returned is CommandResult:
		var command_result: CommandResult = returned
		return null if command_result.is_success() else command_result.copy()
	if returned is Dictionary:
		if bool(returned.get(&"ok", returned.get("ok", false))):
			return null
		var dictionary_message := String(
			returned.get(&"message", returned.get("message", fallback_message))
		)
		return CommandResultType.failed(failure_code, 0, dictionary_message, returned)
	var message := String(returned) if returned is String and not returned.is_empty() else fallback_message
	return CommandResultType.failed(failure_code, 0, message)


func _estimate_wait_before(instance: FacilityInstance, target_request_id: StringName) -> int:
	var outstanding_minutes := 0
	for service_id: StringName in _sorted_keys(instance.active_services):
		var service: ServiceInstance = instance.active_services[service_id]
		outstanding_minutes += service.remaining_minutes()
	for request_id: StringName in instance.queue_entries:
		if request_id == target_request_id:
			break
		var request := get_request(request_id)
		if request != null:
			outstanding_minutes += request.service_minutes
	return ceili(float(outstanding_minutes) / float(maxi(instance.capacity, 1)))


func _cleanup_missing_queue_requests(instance: FacilityInstance) -> void:
	var valid_ids: Array[StringName] = []
	for request_id: StringName in instance.queue_entries:
		if _requests.has(request_id):
			valid_ids.append(request_id)
		else:
			push_warning(
				"Removed corrupt FacilityService queue entry '%s' from '%s'." \
				% [request_id, instance.instance_id]
			)
	instance.queue_entries = valid_ids
	_sort_queue(instance)


func _sort_queue(instance: FacilityInstance) -> void:
	instance.queue_entries.sort_custom(Callable(self, "_queue_entry_less"))


func _queue_entry_less(left_id: StringName, right_id: StringName) -> bool:
	var left := get_request(left_id)
	var right := get_request(right_id)
	if left == null:
		return false
	if right == null:
		return true
	if left.priority != right.priority:
		return left.priority > right.priority
	if left.enqueued_at != right.enqueued_at:
		return left.enqueued_at < right.enqueued_at
	return String(left.request_id) < String(right.request_id)


func _find_active_service(service_id: StringName) -> Dictionary:
	for instance_id: StringName in _sorted_keys(_instances):
		var instance: FacilityInstance = _instances[instance_id]
		if instance.active_services.has(service_id):
			return {
				&"instance": instance,
				&"service": instance.active_services[service_id],
			}
	return {}


func _next_service_id() -> StringName:
	while true:
		var candidate := StringName("service_%08d" % _next_service_sequence)
		_next_service_sequence += 1
		if not _known_service_ids.has(candidate):
			return candidate
	return &""


func _resolve_minute(absolute_minute: int) -> int:
	if absolute_minute >= 0:
		current_minute = maxi(current_minute, absolute_minute)
	return current_minute


func _emit_state_change(instance: FacilityInstance, old_state: int) -> void:
	if old_state != instance.state:
		facility_state_changed.emit(
			instance.instance_id,
			old_state,
			instance.state,
			instance.state_reasons.duplicate()
		)


func _success(details: Dictionary = {}) -> CommandResult:
	return CommandResultType.succeeded(0, details)


func _invalid(message: String, details: Dictionary = {}) -> CommandResult:
	last_error = message
	return CommandResultType.failed(
		CommandResultType.Code.VALIDATION_FAILED,
		0,
		message,
		details
	)


func _not_found(entity_name: String, entity_id: StringName) -> CommandResult:
	var message := "%s '%s' was not found." % [entity_name, entity_id]
	last_error = message
	return CommandResultType.failed(
		CommandResultType.Code.NOT_FOUND,
		0,
		message,
		{&"id": entity_id}
	)


func _duplicate(entity_name: String, entity_id: StringName) -> CommandResult:
	var message := "%s '%s' already exists." % [entity_name, entity_id]
	last_error = message
	return CommandResultType.failed(
		CommandResultType.Code.DUPLICATE_COMMAND_ID,
		0,
		message,
		{&"id": entity_id}
	)


static func _increment_stat(statistics: Dictionary, key: StringName) -> void:
	statistics[key] = int(statistics.get(key, 0)) + 1


static func _value(source: Dictionary, key: StringName, fallback: Variant) -> Variant:
	return source.get(key, source.get(String(key), fallback))


static func _has_value(source: Dictionary, key: StringName) -> bool:
	return source.has(key) or source.has(String(key))


static func _sorted_keys(source: Dictionary) -> Array[StringName]:
	var values: Array[StringName] = []
	for value: Variant in source.keys():
		values.append(StringName(value))
	values.sort_custom(func(a: StringName, b: StringName) -> bool: return String(a) < String(b))
	return values


static func _keys_to_strings(source: Dictionary) -> Array[String]:
	var values: Array[String] = []
	for key: StringName in _sorted_keys(source):
		values.append(String(key))
	return values


static func _id_set(source: Variant) -> Variant:
	if not source is Array:
		return null
	var ids: Dictionary = {}
	for raw_id: Variant in source:
		var id := StringName(raw_id)
		if id.is_empty() or ids.has(id):
			return null
		ids[id] = true
	return ids