PlayFab Server Allocation

// SignalR Hub 메서드
public async Task<MatchmakingResult> FindOrCreateLobby(int maxPlayers)
{
    try
    {
        // 1. 가용한 로비 찾기
        var lobby = _lobbiesManager.FindAvailableLobby(maxPlayers);
        
        if (lobby == null)
        {
            // 2. 로비가 없으면 생성 및 서버 할당
            lobby = _lobbiesManager.CreateLobby(maxPlayers);
            
            try
            {
                // PlayFab으로 서버 할당 시도
                var allocation = await _playFabService.RequestServer(lobby.Id);
                lobby.GameServerIP = allocation.IPV4Address;
                lobby.GameServerPort = allocation.Ports[0].Num;
            }
            catch (Exception ex)
            {
                // Fallback: Render.com 서버 사용
                lobby.GameServerIP = "stupidguysserver.onrender.com";
                lobby.GameServerPort = 7777;
            }
        }
        
        // 3. 플레이어 추가
        if (!lobby.AddMember(Context.ConnectionId))
        {
            return new MatchmakingResult { Success = false };
        }
        
        // 4. 그룹에 추가 (로비별 메시지 브로드캐스트용)
        await Groups.AddToGroupAsync(Context.ConnectionId, $"lobby_{lobby.Id}");
        
        // 5. 로비 상태 업데이트 알림
        await NotifyLobbyUpdated(lobby);
        
        return new MatchmakingResult
        {
            Success = true,
            LobbyId = lobby.Id,
            GameServerIP = lobby.GameServerIP,
            GameServerPort = lobby.GameServerPort
        };
    }
    catch (Exception ex)
    {
        return new MatchmakingResult { Success = false };
    }
}

// PlayFab 서버 할당 서비스
public async Task<ServerAllocation> RequestServer(string sessionId)
{
    // 1. EntityToken 획득
    var authResult = await PlayFabAuthenticationAPI.GetEntityTokenAsync(
        new GetEntityTokenRequest()
    );
    
    // 2. 서버 할당 요청
    var request = new RequestMultiplayerServerRequest
    {
        BuildId = _buildId,
        SessionId = sessionId,
        PreferredRegions = new List<string> { "KoreaCentral" }
    };
    
    var result = await PlayFabMultiplayerAPI.RequestMultiplayerServerAsync(request);
    
    // 3. 서버가 Active 상태가 될 때까지 대기
    await WaitForServerReady(result.SessionId);
    
    return new ServerAllocation
    {
        SessionId = result.SessionId,
        IPV4Address = result.IPV4Address,
        Ports = result.Ports
    };
}

private async Task WaitForServerReady(string sessionId)
{
    var maxAttempts = 30; // 최대 30초
    
    for (int i = 0; i < maxAttempts; i++)
    {
        var details = await PlayFabMultiplayerAPI.GetMultiplayerServerDetailsAsync(
            new GetMultiplayerServerDetailsRequest
            {
                BuildId = _buildId,
                SessionId = sessionId
            }
        );
        
        if (details.ServerDetails.State == "Active")
        {
            return; // 서버 준비 완료
        }
        
        await Task.Delay(1000); // 1초 대기
    }
    
    throw new TimeoutException("Server allocation timeout");
}

// Lobby 클래스
public class Lobby
{
    private readonly object _gate = new object();
    private readonly HashSet<string> _members = new HashSet<string>();
    
    public int MaxPlayers { get; }
    public int CurrentPlayers => _members.Count;
    public bool IsFull => CurrentPlayers >= MaxPlayers;
    
    public bool AddMember(string connectionId)
    {
        lock (_gate)
        {
            if (IsFull) return false;
            return _members.Add(connectionId);
        }
    }
    
    public bool RemoveMember(string connectionId)
    {
        lock (_gate)
        {
            return _members.Remove(connectionId);
        }
    }
}

// LobbiesManager 클래스
public class LobbiesManager
{
    private readonly ConcurrentDictionary<int, Lobby> _lobbies 
        = new ConcurrentDictionary<int, Lobby>();
    
    public Lobby? FindAvailableLobby(int maxPlayers)
    {
        return _lobbies.Values
            .FirstOrDefault(l => !l.IsFull && l.MaxPlayers == maxPlayers);
    }
    
    public Lobby CreateLobby(int maxPlayers)
    {
        var lobbyId = GenerateId();
        var lobby = new Lobby(lobbyId, maxPlayers);
        _lobbies.TryAdd(lobbyId, lobby);
        return lobby;
    }
}

// Unity SignalR 클라이언트
public class MatchmakingClient : MonoBehaviour
{
    private HubConnection _connection;
    
    async void Start()
    {
        // SignalR 연결 생성
        _connection = new HubConnectionBuilder()
            .WithUrl("https://matchmaking.onrender.com/matchmaking")
            .WithAutomaticReconnect() // 자동 재연결
            .Build();
        
        // 서버에서 오는 메시지 수신
        _connection.On<LobbyStatus>("LobbyUpdated", OnLobbyUpdated);
        
        // 연결 시작
        await _connection.StartAsync();
        Debug.Log("Connected to SignalR");
    }
    
    // 매칭 요청
    public async Task<MatchmakingResult> RequestMatching(int maxPlayers)
    {
        var result = await _connection.InvokeAsync<MatchmakingResult>(
            "FindOrCreateLobby", 
            maxPlayers
        );
        
        if (result.Success)
        {
            // 게임 서버 연결
            ConnectToGameServer(result.GameServerIP, result.GameServerPort);
        }
        
        return result;
    }
    
    // 로비 상태 업데이트 수신
    private void OnLobbyUpdated(LobbyStatus status)
    {
        // ⚠️ SignalR 콜백은 백그라운드 스레드에서 실행됨
        // Unity API는 메인 스레드에서만 호출 가능
        UnityMainThreadDispatcher.Enqueue(() =>
        {
            statusText.text = $"Players: {status.CurrentPlayers}/{status.MaxPlayers}";
        });
    }
}

// Unity 메인 스레드 디스패처
public class UnityMainThreadDispatcher : MonoBehaviour
{
    private static readonly Queue<Action> _executionQueue = new Queue<Action>();
    private static UnityMainThreadDispatcher _instance;
    
    void Awake()
    {
        if (_instance == null)
        {
            _instance = this;
            DontDestroyOnLoad(gameObject);
        }
    }
    
    void Update()
    {
        // 메인 스레드에서 큐에 쌓인 작업 실행
        lock (_executionQueue)
        {
            while (_executionQueue.Count > 0)
            {
                _executionQueue.Dequeue().Invoke();
            }
        }
    }
    
    // 백그라운드 스레드에서 호출 가능
    public static void Enqueue(Action action)
    {
        lock (_executionQueue)
        {
            _executionQueue.Enqueue(action);
        }
    }
}

// 로비 퇴장 및 서버 종료
public async Task<bool> LeaveLobby(int lobbyId)
{
    var lobby = _lobbiesManager.GetLobby(lobbyId);
    if (lobby == null) return false;
    
    // 플레이어 제거
    lobby.RemoveMember(Context.ConnectionId);
    
    // 그룹에서 제거
    await Groups.RemoveFromGroupAsync(Context.ConnectionId, $"lobby_{lobbyId}");
    
    // 로비가 비었으면 서버 종료
    if (lobby.IsEmpty)
    {
        await _playFabService.ShutdownServer(lobby.SessionId);
        _lobbiesManager.RemoveLobby(lobbyId);
    }
    else
    {
        // 남은 플레이어들에게 알림
        await NotifyLobbyUpdated(lobby);
    }
    
    return true;
}