extends SceneTree

var _checks := 0
var _failures := 0

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

func _run() -> void:
	var service := OperationsCoordinator.new({&"start_minute": 360})
	_bind(service, [-1, 0, -1, 1, -1, -1, -1], 0)
	_expect(service.advance_to(1439).is_success() and service.get_day_summaries().is_empty(), "23:59 remains open")
	var before_close := service.create_snapshot()
	var boundary_restored := OperationsCoordinator.new()
	_expect(boundary_restored.restore_snapshot(before_close), "23:59 save restores before the first close")
	_bind(boundary_restored, [-1, 0, -1, 1, -1, -1, -1], 0)
	boundary_restored.advance_to(1440)
	_expect(service.advance_to(1440).is_success(), "first partial opening day closes at midnight")
	_expect(boundary_restored.deterministic_digest() == service.deterministic_digest(), "save immediately before midnight closes and pays exactly once")
	var legacy_open := before_close.duplicate(true)
	legacy_open["schema_version"] = 3
	legacy_open.erase("legacy_calendar_last_day")
	legacy_open.erase("legacy_history_last_day")
	var legacy_restored := OperationsCoordinator.new()
	_expect(legacy_restored.restore_snapshot(legacy_open), "legacy save before its first close restores")
	legacy_restored.advance_to(1500)
	_expect(legacy_restored.get_day_summaries().is_empty(), "unclosed legacy first day is not retroactively settled at midnight")
	legacy_restored.advance_to(1800)
	_expect(legacy_restored.get_day_summary(1)[&"closed_at"] == 1800, "legacy first open day closes once at 06:00")
	var day := service.get_day_summary(1)
	_expect(day[&"closed_at"] == 1440 and day[&"period_start_minute"] == 0, "first day uses calendar midnight bounds")
	_expect(service.get_consecutive_insolvency_count() == 1 and service.get_arrears_total() == 0, "a paid loss counts even without arrears")
	service.advance_to(1800)
	_expect(service.get_day_summaries().size() == 1 and not service.get_morning_report(2).is_empty(), "06:00 performs morning work without another close")
	service.advance_to(2880)
	_expect(service.get_consecutive_insolvency_count() == 0, "break-even resets loss streak")
	service.advance_to(4320)
	service.advance_to(5760)
	_expect(service.get_consecutive_insolvency_count() == 0, "profit resets loss streak")
	service.advance_to(8640)
	var saved := service.create_snapshot()
	var restored := OperationsCoordinator.new()
	_expect(restored.restore_snapshot(saved), "two-loss snapshot restores")
	var missing_alert := saved.duplicate(true)
	missing_alert["alerts"].pop_back()
	_expect(not restored.restore_snapshot(missing_alert) and restored.create_snapshot() == saved, "missing loss warning rejects atomically")
	_bind(restored, [-1, 0, -1, 1, -1, -1, -1], 0)
	service.advance_to(10200)
	restored.advance_to(10200)
	_expect(service.current_minute == 10080 and service.is_terminal(), "third loss stops a larger advance exactly at midnight")
	_expect(service.deterministic_digest() == restored.deterministic_digest(), "save/load continuation preserves exact terminal outcome")
	_expect(service.validate_invariants()[&"ok"], "loss history and terminal invariants reconcile")
	var unpaid := OperationsCoordinator.new()
	_bind(unpaid, [1, 1, 1, 1], 50)
	unpaid.advance_to(5760)
	_expect(not unpaid.is_terminal() and unpaid.get_consecutive_insolvency_count() == 0, "profitable closes with arrears never count as losses")
	_expect(not unpaid.can_start_construction_or_investment()[&"allowed"], "unpaid wages still restrict new investment separately")
	_test_legacy()
	print("%s: %d checks" % ["PASS" if _failures == 0 else "FAIL", _checks])
	quit(_failures)

func _test_legacy() -> void:
	var old: Dictionary = str_to_var(FileAccess.get_file_as_string("res://tests/mvp/fixtures/operations_v3_0600.txt"))
	var service := OperationsCoordinator.new()
	_expect(service.restore_snapshot(old), "genuine pre-change v3 financial history restores")
	_expect(service.get_day_summaries() == old["day_summaries"], "legacy closed financial records remain unchanged")
	_expect(service.get_consecutive_insolvency_count() == 2, "historical unpaid streak remains auditable")
	_bind(service, [-1, -1, -1, -1, -1], 0)
	service.advance_to(4320)
	_expect(service.get_day_summaries().size() == 2, "migration does not duplicate the still-open legacy day at midnight")
	service.advance_to(4680)
	_expect(service.get_day_summary(3)[&"period_start_minute"] == 3240 and service.get_consecutive_insolvency_count() == 1, "open legacy day closes once; new loss streak excludes old arrears count")
	var snapshot := service.create_snapshot()
	var restored := OperationsCoordinator.new()
	_expect(restored.restore_snapshot(snapshot), "transition save restores")
	_bind(restored, [-1, -1, -1, -1, -1], 0)
	service.advance_to(5760)
	restored.advance_to(5760)
	_expect(service.get_day_summary(4)[&"period_start_minute"] == 4680 and service.get_day_summary(4)[&"closed_at"] == 5760, "18-hour transition has no gap or overlap")
	_expect(service.deterministic_digest() == restored.deterministic_digest(), "migration replay is deterministic")
	var before := restored.create_snapshot()
	var bad := before.duplicate(true)
	bad["legacy_calendar_last_day"] = 1
	_expect(not restored.restore_snapshot(bad) and restored.create_snapshot() == before, "inconsistent transition marker rejects atomically")
	service.advance_to(8000)
	_expect(service.current_minute == 7200 and service.is_terminal() and service.validate_invariants()[&"ok"], "migrated save ends on three new losses at midnight")

func _bind(service: OperationsCoordinator, profits: Array, arrears: int) -> void:
	service.configure_callbacks(func(payload: Dictionary, phase: StringName, token: Variant) -> Dictionary:
		if phase != &"apply": return {&"ok": true, &"token": token}
		var profit := int(profits[int(payload[&"day"]) - 1])
		return {&"ok": true, &"category_totals": {&"revenue": 100 + profit, &"wages": 100}, &"facility_profit_loss": {}, &"anomalies": [], &"reconciliation_difference": 0, &"settlement": {&"arrears_total": arrears}})

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