extends SceneTree
## Real integration test for ChunkSaveService against a live backend.
##
## Covers docs/architecture/world_persistence_impl.md §8.1/§8.2 (this task's
## §9 "Client/editor task" items 2-3):
##   1. single-chunk PUT with X-Base-Revision (via the JSON base_revision
##      field, exercised through the same route the client hits)
##   2. a real 409 -> re-fetch -> retry cycle
##   3. batch PUT of multiple chunks in one atomic call
##   4. the live_session response flag actually reaching the caller
##   5. persistence survives a real reload (save, then re-fetch, confirm)
##
## Run with:
##     godot --headless --path . --script res://scripts/smoke_test_editor_save.gd
##
## Requires the backend to be running (AGP_API_BASE_URL, default
## http://127.0.0.1:8000).

var passed := 0
var failed := 0


func _initialize() -> void:
	_run()


func _run() -> void:
	await process_frame

	var api := root.get_node("ApiClient")

	randomize()
	var unique_id: int = int(Time.get_unix_time_from_system() * 1000) + randi() % 100000
	var username := "editorsave_%d" % unique_id
	var email := "editorsave_%d@test.example.com" % unique_id
	var reg: Dictionary = await api.register(username, email, "SmokeTest123!", "1990-01-01")
	if not _check("setup: register succeeded", reg.ok):
		print("  detail: ", reg.detail)
		_finish()
		return

	var world_body := JSON.stringify({
		"name": "EditorSave Smoke World %d" % unique_id,
		"visibility": "public",
	})
	var world_result: Dictionary = await api.request(
		HTTPClient.METHOD_POST, "/api/worlds/", world_body, "application/json", true
	)
	if not _check("setup: world created", world_result.ok):
		print("  detail: ", world_result.detail)
		_finish()
		return
	var world_id: int = (world_result.data as Dictionary)["id"]

	var save_service := ChunkSaveService.new()
	save_service.world_id = str(world_id)
	save_service.room_slug = "main"
	root.add_child(save_service)

	await _test_single_save_and_reload(save_service, world_id)
	await _test_409_retry(save_service)
	await _test_batch_save(save_service)
	await _test_live_session_flag(save_service, world_id, api)

	_finish()


## 1 + 5. Single-chunk save at (0,0,0), then a fresh fetch (simulating a
## reload) confirms the edit actually persisted server-side.
func _test_single_save_and_reload(save_service: ChunkSaveService, world_id: int) -> void:
	print("--- single-chunk save, then reload ---")
	var coord := Vector3i(0, 0, 0)
	var model := ChunkEditorModel.create_empty(32, 32, str(world_id), "main", coord)
	model.set_tile_raw(0, 3, 4, 0, 1)

	var save_result: Dictionary = await save_service.save_chunk(model, coord, 0)
	if not _check("save_chunk: single PUT (base_revision 0, create) succeeded", save_result.get("ok", false)):
		print("  detail: ", save_result.get("detail", ""))
		return
	_check("save_chunk: server returned revision 1 for a fresh chunk", int(save_result.get("revision", -1)) == 1)
	_check("save_chunk: live_session present and false (no dedicated server running)",
		save_result.get("live_session", true) == false)

	# Simulate a reload: a brand new fetch, independent of the model we just
	# edited in memory.
	var reload := ChunkSaveService.new()
	reload.world_id = str(world_id)
	reload.room_slug = "main"
	save_service.get_parent().add_child(reload)
	var fetch_result: Dictionary = await reload.fetch_chunk(coord)
	if not _check("reload: fetch after save succeeded", fetch_result.get("ok", false) and fetch_result.get("model") != null):
		print("  detail: ", fetch_result.get("detail", ""))
		reload.queue_free()
		return
	var reloaded_model: ChunkEditorModel = fetch_result["model"]
	_check("reload: revision matches what save reported", int(fetch_result.get("revision", -1)) == int(save_result.get("revision", -2)))
	_check("reload: painted tile (3,4) survived the round trip", reloaded_model.get_tile_raw(0, 3, 4) == 1)
	reload.queue_free()


## 2. A real 409: two independent saves race against the same base_revision;
## the loser's save_chunk() must transparently re-fetch + retry and still
## succeed (this is exactly the class doc's "no delta to replay, only the
## base to refresh" case -- the retry keeps the loser's own edit).
func _test_409_retry(save_service: ChunkSaveService) -> void:
	print("--- real 409 conflict -> re-fetch -> retry ---")
	var coord := Vector3i(1, 0, 0)
	var world_id_str := save_service.world_id

	var model_a := ChunkEditorModel.create_empty(32, 32, world_id_str, "main", coord)
	model_a.set_tile_raw(0, 0, 0, 0, 1)
	var first: Dictionary = await save_service.save_chunk(model_a, coord, 0)
	if not _check("setup: first save at (1,0,0) succeeded", first.get("ok", false)):
		print("  detail: ", first.get("detail", ""))
		return
	var stale_revision: int = int(first.get("revision", 1))

	# Advance the server past what "model_b" below still thinks is current,
	# by saving again from the correct revision.
	var model_advance := ChunkEditorModel.create_empty(32, 32, world_id_str, "main", coord)
	model_advance.set_tile_raw(0, 1, 1, 0, 1)
	var second: Dictionary = await save_service.save_chunk(model_advance, coord, stale_revision)
	if not _check("setup: advancing save succeeded", second.get("ok", false)):
		print("  detail: ", second.get("detail", ""))
		return

	# model_b still has the now-stale revision as its base -- this must 409
	# internally and ChunkSaveService must resolve it on its own.
	var model_b := ChunkEditorModel.create_empty(32, 32, world_id_str, "main", coord)
	model_b.set_tile_raw(0, 2, 2, 0, 1)
	var conflicted: Dictionary = await save_service.save_chunk(model_b, coord, stale_revision)
	if not _check("save_chunk: stale base_revision still ends in success (409 handled internally)", conflicted.get("ok", false)):
		print("  detail: ", conflicted.get("detail", ""))
		return
	_check("save_chunk: reports that a retry actually happened", conflicted.get("retried", false) == true)
	_check("save_chunk: revision advanced past the stale one", int(conflicted.get("revision", -1)) > stale_revision)

	# Confirm the loser's edit (not the advancing one) is what's actually
	# stored -- proves "re-apply the edit" really means "the retry keeps our
	# own locally edited payload".
	var check_fetch: Dictionary = await save_service.fetch_chunk(coord)
	_check("post-conflict fetch: the retried edit (not the earlier advance) is what's stored",
		check_fetch.get("ok", false) and (check_fetch["model"] as ChunkEditorModel).get_tile_raw(0, 2, 2) == 1)


## 3. Batch PUT: two chunks written atomically in one call.
func _test_batch_save(save_service: ChunkSaveService) -> void:
	print("--- batch PUT (multi-chunk edit) ---")
	var world_id_str := save_service.world_id
	var coord_a := Vector3i(5, 0, 0)
	var coord_b := Vector3i(5, 1, 0)

	var model_a := ChunkEditorModel.create_empty(32, 32, world_id_str, "main", coord_a)
	model_a.set_tile_raw(0, 7, 7, 0, 1)
	var model_b := ChunkEditorModel.create_empty(32, 32, world_id_str, "main", coord_b)
	model_b.set_tile_raw(0, 8, 8, 0, 1)

	var batch_result: Dictionary = await save_service.save_batch([
		{"coord": coord_a, "model": model_a, "base_revision": 0},
		{"coord": coord_b, "model": model_b, "base_revision": 0},
	])
	if not _check("save_batch: atomic 2-chunk PUT succeeded", batch_result.get("ok", false)):
		print("  detail: ", batch_result.get("detail", ""))
		return
	_check("save_batch: response lists both chunks", (batch_result.get("chunks", []) as Array).size() == 2)

	var fetch_a: Dictionary = await save_service.fetch_chunk(coord_a)
	var fetch_b: Dictionary = await save_service.fetch_chunk(coord_b)
	_check("save_batch: chunk A actually persisted", fetch_a.get("ok", false) and (fetch_a["model"] as ChunkEditorModel).get_tile_raw(0, 7, 7) == 1)
	_check("save_batch: chunk B actually persisted", fetch_b.get("ok", false) and (fetch_b["model"] as ChunkEditorModel).get_tile_raw(0, 8, 8) == 1)


## 4. live_session: with a fake dedicated-server registration for this
## world, a save must come back with live_session == true instead of the
## flag being silently dropped.
func _test_live_session_flag(save_service: ChunkSaveService, world_id: int, api: Object) -> void:
	print("--- live_session flag surfaced on a write ---")
	# There's no public API to fake a live game-server registration for this
	# world from the client side (that's internal/game_servers.py state) --
	# so this asserts the flag is at least always present and well-typed on
	# a normal save, which is what the editor UI's warning path branches on.
	var coord := Vector3i(9, 9, 0)
	var model := ChunkEditorModel.create_empty(32, 32, str(world_id), "main", coord)
	var result: Dictionary = await save_service.save_chunk(model, coord, 0)
	_check("save_chunk: result always carries a boolean live_session field", result.has("live_session") and typeof(result["live_session"]) == TYPE_BOOL)


func _check(description: String, condition: bool) -> bool:
	if condition:
		print("  PASS: ", description)
		passed += 1
	else:
		printerr("  FAIL: ", description)
		failed += 1
	return condition


func _finish() -> void:
	print("\n=== SMOKE RESULT: %d/%d passed ===" % [passed, passed + failed])
	quit(0 if failed == 0 else 1)