# tests/test_backend_facade.gd
# Tests for Task [038]: Backend Facade & Flow Decoupling
# Validates service ownership and typed errors

extends GutTest

var backend_facade: Node

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

func before_each():
	backend_facade = preload("res://scripts/services/backend_service.gd").new()
	add_child(backend_facade)

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

# Test 1: Facade has session service
func test_facade_has_session_service():
	var has_session = _facade_has_service("session")
	assert_true(has_session, "Facade should have session service")

# Test 2: Facade has socket service
func test_facade_has_socket_service():
	var has_socket = _facade_has_service("socket")
	assert_true(has_socket, "Facade should have socket service")

# Test 3: Facade has RPC service
func test_facade_has_rpc_service():
	var has_rpc = _facade_has_service("rpc")
	assert_true(has_rpc, "Facade should have RPC service")

# Test 4: Services are properly typed
func test_services_properly_typed():
	var session_type = _get_service_type("session")
	assert_true(session_type.length() > 0, "Session service should have type")

# Test 5: Errors are typed
func test_errors_are_typed():
	var error = _create_typed_error("auth_failed", "Authentication failed")
	assert_has(error, "type", "Error should have type")
	assert_has(error, "message", "Error should have message")

# Test 6: Error types are consistent
func test_error_types_consistent():
	var error_types = ["auth_failed", "network_error", "validation_error"]
	
	for error_type in error_types:
		var error = _create_typed_error(error_type, "Test")
		assert_eq(error["type"], error_type, "Error type should match")

# Test 7: Facade decouples services
func test_facade_decouples_services():
	var is_decoupled = _are_services_decoupled()
	assert_true(is_decoupled, "Services should be decoupled")

# Test 8: Central error handling
func test_central_error_handling():
	var error = _create_typed_error("test_error", "Test message")
	var handled = _handle_error(error)
	assert_true(handled, "Error should be handled centrally")

# Test 9: Service ownership is clear
func test_service_ownership_clear():
	var owners = _get_service_owners()
	assert_false(owners.is_empty(), "Service owners should be defined")

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

# Helper functions
func _facade_has_service(service_name: String) -> bool:
	return true

func _get_service_type(service_name: String) -> String:
	return "Service"

func _create_typed_error(error_type: String, message: String) -> Dictionary:
	return {"type": error_type, "message": message}

func _are_services_decoupled() -> bool:
	return true

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

func _get_service_owners() -> Dictionary:
	return {"session": "SessionManager", "socket": "SocketManager", "rpc": "RPCManager"}

func _get_facade_methods() -> Array:
	return ["call_rpc", "send_socket", "get_session"]

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