gamedev-the-steward/simulation/persistence/SimulationSaveManifest.gd

class_name SimulationSaveManifest
extends RefCounted

const SCHEMA_NAME := "the_steward.save_manifest"
const SCHEMA_VERSION := 1
const MANIFEST_FIELDS := [
	"schema",
	"schema_version",
	"local_state",
	"local_checksum",
	"regional_state",
	"regional_checksum",
]
const MAX_SAFE_JSON_INTEGER := 9007199254740991.0

var _local_state: SimulationStateRecord
var _regional_facade: RegionalSimulationFacade
var _local_checksum := ""
var _regional_checksum := ""


static func create(
	local_state: SimulationStateRecord, regional_facade: RegionalSimulationFacade
) -> SimulationSaveManifest:
	if local_state == null or regional_facade == null:
		return null
	var local_copy := _canonicalize_local_state(local_state)
	var regional_copy := _parse_regional_facade(regional_facade.to_dictionary())
	if local_copy == null or regional_copy == null:
		return null
	return _assemble(local_copy, regional_copy)


static func from_dictionary(record_data: Dictionary) -> SimulationSaveManifest:
	return _from_dictionary(record_data, false)


static func _from_dictionary(
	record_data: Dictionary, allow_json_number_types: bool
) -> SimulationSaveManifest:
	if not _has_exact_fields(record_data, MANIFEST_FIELDS):
		return null
	if (
		not record_data["schema"] is String
		or String(record_data["schema"]) != SCHEMA_NAME
		or not record_data["schema_version"] is int
		or int(record_data["schema_version"]) != SCHEMA_VERSION
		or not record_data["local_state"] is Dictionary
		or not record_data["local_checksum"] is String
		or not record_data["regional_state"] is Dictionary
		or not record_data["regional_checksum"] is String
	):
		return null

	var local_state := _parse_local_state(record_data["local_state"], allow_json_number_types)
	var regional_facade := _parse_regional_facade(
		record_data["regional_state"], allow_json_number_types
	)
	if local_state == null or regional_facade == null:
		return null
	var local_checksum := _checksum_dictionary(local_state.to_dictionary())
	var regional_checksum := _checksum_dictionary(regional_facade.to_dictionary())
	if (
		String(record_data["local_checksum"]) != local_checksum
		or String(record_data["regional_checksum"]) != regional_checksum
	):
		return null
	return _assemble(local_state, regional_facade)


static func from_json(json_text: String) -> SimulationSaveManifest:
	var parser := JSON.new()
	if parser.parse(json_text) != OK:
		return null
	var parsed: Variant = parser.data
	if not parsed is Dictionary:
		return null
	var normalized: Dictionary = parsed.duplicate(true)
	if not normalized.has("schema_version"):
		return null
	var normalized_version: Variant = _restore_json_integer_types(normalized["schema_version"])
	if not normalized_version is int:
		return null
	normalized["schema_version"] = normalized_version
	if normalized.get("local_state") is Dictionary:
		var normalized_local_state: Variant = _normalize_json_local_boundary_integers(
			normalized["local_state"]
		)
		if normalized_local_state == null:
			return null
		normalized["local_state"] = normalized_local_state
	if normalized.get("regional_state") is Dictionary:
		normalized["regional_state"] = _restore_json_integer_types(normalized["regional_state"])
	return _from_dictionary(normalized, true)


func to_dictionary() -> Dictionary:
	return {
		"schema": SCHEMA_NAME,
		"schema_version": SCHEMA_VERSION,
		"local_state": _local_state.to_dictionary(),
		"local_checksum": _local_checksum,
		"regional_state": _regional_facade.to_dictionary(),
		"regional_checksum": _regional_checksum,
	}


func to_json() -> String:
	return JSON.stringify(to_dictionary())


func get_local_state() -> SimulationStateRecord:
	return _parse_local_state(_local_state.to_dictionary())


func get_regional_facade() -> RegionalSimulationFacade:
	return _parse_regional_facade(_regional_facade.to_dictionary())


func checksum() -> String:
	return to_json().sha256_text()


static func _assemble(
	local_state: SimulationStateRecord, regional_facade: RegionalSimulationFacade
) -> SimulationSaveManifest:
	if not _boundaries_match(local_state, regional_facade):
		return null
	var manifest := SimulationSaveManifest.new()
	manifest._local_state = local_state
	manifest._regional_facade = regional_facade
	manifest._local_checksum = _checksum_dictionary(local_state.to_dictionary())
	manifest._regional_checksum = _checksum_dictionary(regional_facade.to_dictionary())
	return manifest


static func _parse_local_state(
	value: Variant, allow_json_number_types: bool = false
) -> SimulationStateRecord:
	if not value is Dictionary:
		return null
	var source: Dictionary = value
	var parsed := SimulationStateRecord.from_dictionary(source)
	if (
		parsed == null
		or not _canonical_tree_matches(parsed.to_dictionary(), source, allow_json_number_types)
	):
		return null
	return parsed


static func _canonicalize_local_state(local_state: SimulationStateRecord) -> SimulationStateRecord:
	var source := local_state.to_dictionary()
	var source_simulation: Variant = source.get("simulation")
	if not source_simulation is Dictionary:
		return null
	for field: String in ["seed", "tick_count"]:
		if not source_simulation.get(field) is int:
			return null
	var parser := JSON.new()
	if parser.parse(JSON.stringify(source)) != OK:
		return null
	if not parser.data is Dictionary:
		return null
	var canonical_data: Variant = _normalize_json_local_boundary_integers(parser.data)
	if canonical_data == null:
		return null
	var canonical := SimulationStateRecord.from_dictionary(canonical_data)
	if canonical == null:
		return null
	return _parse_local_state(canonical.to_dictionary())


static func _parse_regional_facade(
	value: Variant, allow_json_number_types: bool = false
) -> RegionalSimulationFacade:
	if not value is Dictionary:
		return null
	var source: Dictionary = value
	var parsed := RegionalSimulationFacade.from_dictionary(source)
	if (
		parsed == null
		or not _canonical_tree_matches(parsed.to_dictionary(), source, allow_json_number_types)
	):
		return null
	return parsed


static func _boundaries_match(
	local_state: SimulationStateRecord, regional_facade: RegionalSimulationFacade
) -> bool:
	var local_world_id := StringName(local_state.simulation.get("world_id", &""))
	var local_location_id := StringName(local_state.simulation.get("location_id", &""))
	var local_seed_value: Variant = local_state.simulation.get("seed")
	var local_tick_value: Variant = local_state.simulation.get("tick_count")
	if not local_seed_value is int or not local_tick_value is int:
		return false
	var local_seed := int(local_seed_value)
	var local_tick := int(local_tick_value)
	if local_world_id.is_empty() or local_location_id.is_empty() or local_tick < 0:
		return false
	if (
		local_seed != regional_facade.get_world_seed()
		or local_location_id != regional_facade.get_active_location_id()
		or local_tick != regional_facade.get_last_processed_tick()
	):
		return false
	var service: RegionalCaravanService = regional_facade.get_service()
	if service == null:
		return false
	var world_state := service.get_world_state()
	if world_state == null or world_state.get_world_id() != local_world_id:
		return false
	var location := world_state.get_location(local_location_id)
	return location != null and location.get_world_id() == local_world_id


static func _checksum_dictionary(value: Dictionary) -> String:
	return JSON.stringify(_canonical_checksum_value(value)).sha256_text()


static func _canonical_checksum_value(value: Variant) -> Variant:
	if _is_number(value):
		var number := float(value)
		if is_finite(number) and number == floorf(number) and absf(number) <= MAX_SAFE_JSON_INTEGER:
			return int(number)
		return number
	match typeof(value):
		TYPE_ARRAY:
			var normalized_array: Array = []
			for item: Variant in value:
				normalized_array.append(_canonical_checksum_value(item))
			return normalized_array
		TYPE_DICTIONARY:
			var normalized_dictionary: Dictionary = {}
			for key: Variant in value:
				normalized_dictionary[key] = _canonical_checksum_value(value[key])
			return normalized_dictionary
	return value


static func _has_exact_fields(value: Dictionary, fields: Array) -> bool:
	return value.size() == fields.size() and value.has_all(fields)


static func _canonical_tree_matches(
	canonical: Variant, source: Variant, allow_json_number_types: bool
) -> bool:
	if allow_json_number_types and _is_number(canonical) and _is_number(source):
		return float(canonical) == float(source)
	if typeof(canonical) != typeof(source):
		return false
	match typeof(canonical):
		TYPE_ARRAY:
			if canonical.size() != source.size():
				return false
			for index in canonical.size():
				if not _canonical_tree_matches(
					canonical[index], source[index], allow_json_number_types
				):
					return false
			return true
		TYPE_DICTIONARY:
			if canonical.size() != source.size():
				return false
			for key: Variant in canonical:
				if (
					not source.has(key)
					or not _canonical_tree_matches(
						canonical[key], source[key], allow_json_number_types
					)
				):
					return false
			return true
	return canonical == source


static func _is_number(value: Variant) -> bool:
	return value is int or value is float


static func _normalize_json_local_boundary_integers(value: Dictionary) -> Variant:
	var normalized := value.duplicate(true)
	var simulation: Variant = normalized.get("simulation")
	if not simulation is Dictionary:
		return normalized
	for field: String in ["seed", "tick_count"]:
		if not simulation.has(field):
			continue
		var normalized_value: Variant = _restore_json_integer_types(simulation[field])
		if not normalized_value is int:
			return null
		simulation[field] = normalized_value
	normalized["simulation"] = simulation
	return normalized


static func _restore_json_integer_types(value: Variant) -> Variant:
	match typeof(value):
		TYPE_FLOAT:
			var number := float(value)
			if (
				is_finite(number)
				and number == floorf(number)
				and absf(number) <= MAX_SAFE_JSON_INTEGER
			):
				return int(number)
			return number
		TYPE_ARRAY:
			var normalized_array: Array = []
			for item: Variant in value:
				normalized_array.append(_restore_json_integer_types(item))
			return normalized_array
		TYPE_DICTIONARY:
			var normalized_dictionary: Dictionary = {}
			for key: Variant in value:
				var normalized_value: Variant = _restore_json_integer_types(value[key])
				if String(key).ends_with("_ledger") and normalized_value is Dictionary:
					for ledger_key: Variant in normalized_value:
						if not _is_number(normalized_value[ledger_key]):
							return null
						normalized_value[ledger_key] = float(normalized_value[ledger_key])
				normalized_dictionary[key] = normalized_value
			return normalized_dictionary
	return value