using System;
using System.Threading.Tasks;
using LobbyRelaySample.lobby;
using Unity.Services.Lobbies.Models;
using UnityEngine;

// namespace LobbyRelaySample
// {
//     /// <summary>
//     /// Keep updated on changes to a joined lobby, at a speed compliant with Lobby's rate limiting.
//     /// </summary>
//     public class LobbySynchronizer : IDisposable
//     {
//         LocalLobby m_LocalLobby;
//         LocalPlayer m_LocalUser;
//         LobbyManager m_LobbyManager;
//         bool m_LocalChanges = false;
//
//         const int k_approvalMaxMS = 10000; // Used for determining if a user should timeout if they are unable to connect.
//
//         int m_lifetime = 0;
//         const int k_UpdateIntervalMS = 1000;
//
//         public LobbySynchronizer(LobbyManager lobbyManager)
//         {
//             m_LobbyManager = lobbyManager;
//         }
//
//         public void StartSynch(LocalLobby localLobby, LocalPlayer localUser)
//         {
//             m_LocalUser = localUser;
//             m_LocalLobby = localLobby;
//             m_LocalLobby.LobbyID.onChanged += OnLobbyIdChanged;
//             m_LocalChanges = true;
//             #pragma warning disable 4014
//             UpdateLoopAsync();
//             #pragma warning restore 4014
//             m_lifetime = 0;
//         }
//
//
//         public void EndSynch()
//         {
//             m_LocalChanges = false;
//
//             if (m_LocalLobby != null)
//                 m_LocalLobby.LobbyID.onChanged -= OnLobbyIdChanged;
//
//             m_LocalLobby = null;
//         }
//
//         /// <summary>
//         /// If there have been any data changes since the last update, push them to Lobby. Regardless, pull for the most recent data.
//         /// (Unless we're already awaiting a query, in which case continue waiting.)
//         /// </summary>
//         async Task UpdateLoopAsync()
//         {
//             Lobby latestLobby = null;
//
//             while (m_LocalLobby != null)
//             {
//                 latestLobby = await GetLatestRemoteLobby();
//
//                 if (IfRemoteLobbyChanged(latestLobby))
//                 {
//                     //Pulling remote changes, and applying them to the local lobby usually flags it as changed,
//                     //Causing another pull, the RemoteToLocal converter ensures this does not happen by flagging the lobby.
//                     LobbyConverters.RemoteToLocal(latestLobby, m_LocalLobby, false);
//                 }
//                 Debug.Log(m_LocalLobby.ToString());
//
//                 if (!LobbyHasHost())
//                 {
//                     LeaveLobbyBecauseNoHost();
//                     break;
//                 }
//
//                 var areAllusersReady = AreAllUsersReady();
//                 if (areAllusersReady && m_LocalLobby.LocalLobbyState.Value == LobbyState.Lobby)
//                 {
//                     GameManager.Instance.BeginCountDown();
//                 }
//                 else if (!areAllusersReady && m_LocalLobby.LocalLobbyState.Value == LobbyState.CountDown)
//                 {
//                     GameManager.Instance.CancelCountDown();
//                 }
//
//                 m_lifetime += k_UpdateIntervalMS;
//                 await Task.Delay(k_UpdateIntervalMS);
//             }
//         }
//
//         async Task<Lobby> GetLatestRemoteLobby()
//         {
//             Lobby latestLobby = null;
//             if (m_LocalLobby.IsLobbyChanged())
//             {
//                 latestLobby = await PushDataToLobby();
//             }
//             else
//             {
//                 latestLobby = await m_LobbyManager.GetLobbyAsync();
//             }
//
//             return latestLobby;
//         }
//
//         bool IfRemoteLobbyChanged(Lobby remoteLobby)
//         {
//             var remoteLobbyTime = remoteLobby.LastUpdated.ToFileTimeUtc();
//             var localLobbyTime = m_LocalLobby.LastUpdated.Value;
//             var isLocalOutOfDate = remoteLobbyTime > localLobbyTime;
//             return isLocalOutOfDate;
//         }
//
//         async Task<Lobby> PushDataToLobby()
//         {
//             m_LocalChanges = false;
//
//             if (m_LocalUser.IsHost.Value)
//                 await m_LobbyManager.UpdateLobbyDataAsync(
//                     LobbyConverters.LocalToRemoteLobbyData(m_LocalLobby));
//
//             return await m_LobbyManager.UpdatePlayerDataAsync(
//                 LobbyConverters.LocalToRemoteUserData(m_LocalUser));
//         }
//
//         bool AreAllUsersReady()
//         {
//             foreach (var lobbyUser in m_LocalLobby.LocalPlayers.Values)
//             {
//                 if (lobbyUser.PlayerStatus.Value != PlayerStatus.Ready)
//                 {
//                     return false;
//                 }
//             }
//
//             return true;
//         }
//
//         bool LobbyHasHost()
//         {
//             if (!m_LocalUser.IsHost.Value)
//             {
//                 foreach (var lobbyUser in m_LocalLobby.LocalPlayers)
//                 {
//                     if (lobbyUser.Value.IsHost.Value)
//                         return true;
//                 }
//
//                 return false;
//             }
//
//             return true;
//         }
//
//         void LeaveLobbyBecauseNoHost()
//         {
//             LogHandlerSettings.Instance.SpawnErrorPopup(
//                 "Host left the lobby! Disconnecting...");
//             Locator.Get.Messenger.OnReceiveMessage(MessageType.EndGame, null);
//             GameManager.Instance.ChangeMenuState(GameState.JoinMenu);
//         }
//
//         public void OnLobbyIdChanged(string lobbyID)
//         {
//             if (string.IsNullOrEmpty(lobbyID)
//             ) // When the player leaves, their LocalLobby is cleared out.
//             {
//                 EndSynch();
//             }
//         }
//
//         public void Dispose()
//         {
//             EndSynch();
//         }
//     }
// }