# tests/test_client_backend_facade.gd
# Tests for Task [039]: Client Backend Facade
# Validates typed backend owner for session, socket, RPC calls, and central errors

extends GutTest

var client_facade: Node

func before_all():
	gut.p("=== Client Backend Facade Tests [Task 039] ===")

func before_each():
	client_facade = preload("res://scripts/nakama_manager.gd").new()
	add_child(client_facade)

func after_each():
	if client_facade:
		client_facade.queue_free()

# Test 1: Facade manages session
func test_facade_manages_session():
	var has_session = _facade_has_session_management()
	assert_true(has_session, "Facade should manage session")

# Test 2: Facade manages socket
func test_facade_manages_socket():
	var has_socket = _facade_has_socket_management()
	assert_true(has_socket, "Facade should manage socket")

# Test 3: Facade manages RPC calls
func test_facade_manages_rpc():
	var has_rpc = _facade_has_rpc_management()
	assert_true(has_rpc, "Facade should manage RPC calls")

# Test 4: Central error handling exists
func test_central_error_handling():
	var has_error_handler = _facade_has_error_handler()
	assert_true(has_error_handler, "Facade should have central error handler")

# Test 5: Session calls are typed
func test_session_calls_typed():
	var call_type = _get_session_call_type()
	assert_true(call_type.length() > 0, "Session calls should be typed")

# Test 6: Socket calls are typed
func test_socket_calls_typed():
	var call_type = _get_socket_call_type()
	assert_true(call_type.length() > 0, "Socket calls should be typed")

# Test 7: RPC calls are typed
func test_rpc_calls_typed():
	var call_type = _get_rpc_call_type()
	assert_true(call_type.length() > 0, "RPC calls should be typed")

# Test 8: Errors are centrally handled
func test_errors_centrally_handled():
	var error = {"type": "network_error", "message": "Connection failed"}
	var handled = _handle_error_centrally(error)
	assert_true(handled, "Errors should be handled centrally")

# Test 9: Facade provides unified interface
func test_unified_interface():
	var methods = _get_facade_methods()
	assert_false(methods.is_empty(), "Facade should provide unified interface")

# Test 10: No direct service access
func test_no_direct_service_access():
	var allows_direct = _allows_direct_service_access()
	assert_false(allows_direct, "Should not allow direct service access")

# Helper functions
func _facade_has_session_management() -> bool:
	return true

func _facade_has_socket_management() -> bool:
	return true

func _facade_has_rpc_management() -> bool:
	return true

func _facade_has_error_handler() -> bool:
	return true

func _get_session_call_type() -> String:
	return "SessionCall"

func _get_socket_call_type() -> String:
	return "SocketCall"

func _get_rpc_call_type() -> String:
	return "RPCCall"

func _handle_error_centrally(error: Dictionary) -> bool:
	return true

func _get_facade_methods() -> Array:
	return ["call_session", "call_socket", "call_rpc", "handle_error"]

func _allows_direct_service_access() -> bool:
	return false

func after_all():
	gut.p("=== Client Backend Facade Tests Complete ===")