using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Net.NetworkInformation;
using Firesplash.UnityAssets.SocketIO;
using HeathenEngineering.SteamApi.Foundation;
using I2.Loc;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Steamworks;
using TMPro;
using UnityEngine;
using UnityEngine.Serialization;

public class ServerManager : MonoBehaviour
{
	[Serializable]
	public class PlayerData
	{
		public string PLAYER_ID;

		public string COUNTRY;

		public string PLAYER_NAME;

		public string PLAYER_PROFILE_NAME;

		public string GAME_VERSION;

		public int PROFILE_INDEX;

		public int PLAYER_LEVEL;

		public float PLAYER_CASH;

		public float TOTAL_FISH_WEIGHT;

		public int TOTAL_FISH;
	}

	private class RankingFishData
	{
		public string PLAYER_ID;

		public string PLAYER_NAME;

		public int PROFILE_INDEX;

		public int POINTS;

		public int FISH_ID;

		public float FISH_WEIGHT;

		public string GAME_MODE;

		public int MAP_ID;
	}

	private class GetRankingsData
	{
		public int from;

		public int to;

		public string GAME_MODE;
	}

	[Serializable]
	public class RankingPlayersData
	{
		public string PLAYER_ID;

		public string PLAYER_NAME;

		public int PROFILE_INDEX;

		public float TOTAL_FISH_WEIGHT;

		public int BEST_FISH_ID;

		public float BEST_FISH_WEIGHT;

		public int TOTAL_FISH;

		public int POINTS;
	}

	[Serializable]
	private class RankingOwnData
	{
		public string PLAYER_ID;

		public int PROFILE_INDEX;

		public string GAME_MODE;
	}

	[Serializable]
	public class GetRankingOwnData
	{
		public string PLAYER_ID;

		public string PLAYER_NAME;

		public int PROFILE_INDEX;

		public float TOTAL_FISH_WEIGHT;

		public int BEST_FISH_ID;

		public float BEST_FISH_WEIGHT;

		public int TOTAL_FISH;

		public int POINTS;

		public int POSITION;
	}

	[Serializable]
	public class PlayerLocationData
	{
		public string PLAYER_ID;

		public string COUNTRY;

		public string PLAYER_NAME;

		public string PLAYER_PROFILE_NAME;

		public string GAME_VERSION;

		public int PROFILE_INDEX;

		public int PLAYER_LEVEL;

		public float PLAYER_CASH;

		public float TOTAL_FISH_WEIGHT;

		public int TOTAL_FISH;

		public int LOCATION_ID;
	}

	private class GetRankingsLocationData
	{
		public int from;

		public int to;

		public string GAME_MODE;

		public int locationID;
	}

	[Serializable]
	public class RankingPlayersLocationData
	{
		public string PLAYER_ID;

		public string PLAYER_NAME;

		public int PROFILE_INDEX;

		public float TOTAL_FISH_WEIGHT;

		public int BEST_FISH_ID;

		public float BEST_FISH_WEIGHT;

		public int TOTAL_FISH;

		public int POINTS;

		public int MAP_ID;
	}

	[Serializable]
	private class RankingOwnLocationData
	{
		public string PLAYER_ID;

		public int PROFILE_INDEX;

		public string GAME_MODE;

		public int locationID;
	}

	[Serializable]
	public class GetRankingOwnLocationData
	{
		public string PLAYER_ID;

		public string PLAYER_NAME;

		public int PROFILE_INDEX;

		public float TOTAL_FISH_WEIGHT;

		public int BEST_FISH_ID;

		public float BEST_FISH_WEIGHT;

		public int TOTAL_FISH;

		public int POINTS;

		public int POSITION;

		public int MAP_ID;
	}

	[Serializable]
	private class RewardOwnData
	{
		public string PLAYER_ID;

		public string PLAYER_NAME;

		public int PROFILE_INDEX;
	}

	[Serializable]
	public class GetRewardOwnData
	{
		public string REWARD_TYPE;

		public string REWARD;
	}

	[Serializable]
	public class PlayerChatData
	{
		public string PLAYER_ID;

		public string PLAYER_NAME;

		public string COUNTRY;

		public string LOCATION_ID;
	}

	[Serializable]
	public class GetPlayerChatRoomData
	{
		public string ID;

		public string LOCATION_ID;

		public string PLAYERS;

		public int MAX_PLAYERS;
	}

	[Serializable]
	public class ReconnectPlayerData
	{
		public string PLAYER_ID;

		public string PLAYER_NAME;

		public string COUNTRY;

		public string ROOM_ID;

		public string LOCATION_ID;
	}

	[Serializable]
	public class Message
	{
		public string MESSAGE_TYPE;

		public string PLAYER_ID;

		public string PLAYER_NAME;

		public string COUNTRY;

		public string LOCATION_ID;

		public string MESSAGE;
	}

	[Serializable]
	public class FishMessage
	{
		public string PLAYER_ID;

		public string PLAYER_NAME;

		public int FISH_ID;

		public float FISH_WEIGHT;
	}

	[Serializable]
	private class TournamentData
	{
		public int ID;

		public string NAME;

		public string TYPE;

		public string VISABLE_TYPE;

		public string TASK;

		public string METHOD;

		public int MAP_ID;

		public int DURATION;

		public int PARTICIPANTS_MAX;

		public int ENTRY_FEE;

		public int LEVEL_MIN;

		public int LEVEL_MAX;

		public string CREATOR_PLAYER_ID;

		public int CREATOR_PROFILE_INDEX;

		public string CREATOR_PLAYER_NAME;

		public long TIME_START;

		public int TIME_TO_END_S;

		public int TIME_CREATE_S;
	}

	[Serializable]
	private class TournamentParticipantsData
	{
		public int ID;

		public int TOURNAMENT_ID;

		public string PLAYER_ID;

		public string PLAYER_NAME;

		public int PROFILE_INDEX;

		public int PLAYER_LEVEL;

		public int TOURNAMENTS_WON;

		public int RANKING_POINTS;

		public int BEST_FISH_ID;

		public float VALUE;

		public int JOINED_TIMELEFT;

		public string STATUS;
	}

	[Serializable]
	private class TournamentJoinData
	{
		public int TOURNAMENT_ID;

		public int PARTICIPANTS_MAX;

		public string PLAYER_ID;

		public string PLAYER_NAME;

		public int PROFILE_INDEX;

		public int PLAYER_LEVEL;

		public int TOURNAMENTS_WON;

		public int RANKING_POINTS;
	}

	[Serializable]
	private class TournamentJoinedIdsData
	{
		public int TOURNAMENT_ID;
	}

	[Serializable]
	private class TournamentInvitesData
	{
		public int TOURNAMENT_ID;

		public string TOURNAMENT_NAME;

		public string PLAYER_ID;

		public string SEND_PLAYER_NAME;
	}

	[Serializable]
	private class TournamentCreatorData
	{
		public int ID;

		public string NAME;

		public string TYPE;

		public string TYPE_PLAYER_TOURNAMENT;

		public string TASK;

		public string METHOD;

		public int MAP_ID;

		public int DURATION;

		public int PARTICIPANTS_MAX;

		public int ENTRY_FEE;

		public int LEVEL_MIN;

		public int LEVEL_MAX;

		public string PLAYER_ID;

		public string PLAYER_NAME;

		public int PROFILE_INDEX;

		public string INVITES;
	}

	[Serializable]
	private class TournamentFishData
	{
		public int TOURNAMENT_ID;

		public string PLAYER_ID;

		public int PROFILE_INDEX;

		public string TASK;

		public int FISH_ID;

		public float FISH_WEIGHT;

		public int MAP_ID;
	}

	private enum APITestStage
	{
		None = 0,
		RewardsAndOwnRanking = 1,
		ServerTime = 2,
		OtherPlayersRanking = 3,
		UpdatePlayerData = 4,
		Tournaments_0 = 5
	}

	public string serverVersion;

	public SocketIOCommunicator socket;

	private static ServerManager instance;

	[FormerlySerializedAs("UserData")]
	public SteamUserData userData;

	public long serverTime;

	public bool isServerTimeUpdated;

	private long serverTimeOnStart;

	private ChatManager chatManager;

	public bool getParticipantReady;

	public static bool isBanned;

	private RankingFishData rankingFishData = new RankingFishData();

	private GetRankingsData getRankingsData = new GetRankingsData();

	public List<RankingPlayersData> rankingPlayersData;

	public GetRankingOwnData rankingOwnData = new GetRankingOwnData();

	private GetRankingsLocationData getRankingsLocationData = new GetRankingsLocationData();

	public List<RankingPlayersLocationData> rankingPlayersLocationData;

	public GetRankingOwnLocationData rankingOwnLocationData = new GetRankingOwnLocationData();

	public List<GetRewardOwnData> rewardsOwnData;

	private PlayerChatData playerChatData = new PlayerChatData();

	public GetPlayerChatRoomData getPlayerChatRoomData = new GetPlayerChatRoomData();

	private float getTimeTimer = 1f;

	private bool isFirstUpdate;

	private APITestStage apiTestStage;

	public bool apiTestRunning;

	private bool testServerWasTimeout;

	private string testServerEventNameLast;

	private string testServerResponseLast;

	private int socketEventID;

	public static ServerManager Instance => instance;

	private void Awake()
	{
		UnityEngine.Object.DontDestroyOnLoad(this);
		if (instance == null)
		{
			instance = this;
		}
		else if (instance != this)
		{
			UnityEngine.Object.Destroy(base.gameObject);
		}
	}

	public void Start()
	{
		socket.Instance.On("ON_GET_REWARDS_OWN", delegate(string payload)
		{
			if (!apiTestRunning)
			{
				OnGetOwnRewards(payload);
			}
			else
			{
				TestServerResponse("ON_GET_REWARDS_OWN", payload);
			}
		});
		socket.Instance.On("ON_GET_RANKING_OWN", delegate(string payload)
		{
			if (!apiTestRunning)
			{
				OnGetOwnRanking(payload);
			}
			else
			{
				TestServerResponse("ON_GET_RANKING_OWN", payload);
			}
		});
		socket.Instance.On("ON_GET_RANKING_PLAYERS", delegate(string payload)
		{
			if (!apiTestRunning)
			{
				OnGetPlayersRanking(payload);
			}
			else
			{
				TestServerResponse("ON_GET_RANKING_PLAYERS", payload);
			}
		});
		socket.Instance.On("ON_GET_RANKING_LOCATION_OWN", delegate(string payload)
		{
			if (!apiTestRunning)
			{
				OnGetOwnRankingLocation(payload);
			}
			else
			{
				TestServerResponse("ON_GET_RANKING_LOCATION_OWN", payload);
			}
		});
		socket.Instance.On("ON_GET_RANKING_LOCATION_PLAYERS", delegate(string payload)
		{
			if (!apiTestRunning)
			{
				OnGetPlayersRankingLocation(payload);
			}
			else
			{
				TestServerResponse("ON_GET_RANKING_LOCATION_PLAYERS", payload);
			}
		});
		socket.Instance.On("ON_GET_SERVER_TIME", delegate(string payload)
		{
			if (!apiTestRunning)
			{
				OnGetServerTime(payload);
			}
			else
			{
				TestServerResponse("ON_GET_SERVER_TIME", payload);
			}
		});
		socket.Instance.On("CONNECT", delegate
		{
			Debug.Log("Po³¹czono z serwerem UFS2_server");
			PlayerReconnect();
		});
		socket.Instance.On("ON_GET_TOURNAMENTS", delegate(string payload)
		{
			if (!apiTestRunning)
			{
				OnGetTournaments(payload);
			}
			else
			{
				TestServerResponse("ON_GET_TOURNAMENTS", payload);
			}
		});
		socket.Instance.On("ON_GET_TOURNAMENT_PARTICIPANTS", delegate(string payload)
		{
			OnGetTournamentParticipants(payload);
		});
		socket.Instance.On("ON_JOIN_TOURNAMENT_FAILED", delegate(string payload)
		{
			OnJoinTournamentFailed(payload);
		});
		socket.Instance.On("ON_JOIN_TOURNAMENT_SUCCESS", delegate(string payload)
		{
			OnJoinTournamentSuccess(payload);
		});
		socket.Instance.On("ON_GET_TOURNAMENT_JOINED_IDS", delegate(string payload)
		{
			if (!apiTestRunning)
			{
				OnGetTournamentJoinedIds(payload);
			}
			else
			{
				TestServerResponse("ON_GET_TOURNAMENT_JOINED_IDS", payload);
			}
		});
		socket.Instance.On("ON_CREATE_TOURNAMENT", delegate(string payload)
		{
			OnCreateTournament(payload);
		});
		socket.Instance.On("ON_GET_TOURNAMENT_INVITES", delegate(string payload)
		{
			if (!apiTestRunning)
			{
				OnGetTournamentInvites(payload);
			}
			else
			{
				TestServerResponse("ON_GET_TOURNAMENT_INVITES", payload);
			}
		});
		socket.Instance.On("ON_GET_DELETE_TOURNAMENT", delegate
		{
			OnGetTournamentDeleteByPlayer();
		});
		socket.Instance.On("ON_GET_BANNED", delegate(string payload)
		{
			OnGetBannedPlayer(payload);
		});
		socket.Instance.Connect();
		InvokeRepeating("UpdatePlayerData", 60f, 60f);
	}

	private void Update()
	{
		getTimeTimer = Mathf.MoveTowards(getTimeTimer, 0f, Time.unscaledDeltaTime);
		if (getTimeTimer == 0f)
		{
			RepeatTime();
			getTimeTimer = 1f;
		}
		FirstPlayerUpdate();
	}

	private void RepeatTime()
	{
		if (socket.Instance.IsConnected())
		{
			socket.Instance.Emit("GET_TIME_FROM_SERVER");
			serverTime = serverTimeOnStart;
		}
		else
		{
			long num = DateTimeOffset.Now.ToUnixTimeSeconds();
			serverTime = num;
		}
	}

	public void OnGetServerTime(string data)
	{
		long num = long.Parse(JObject.Parse(data)["time"].ToString());
		serverTimeOnStart = num;
		isServerTimeUpdated = true;
	}

	public long GetServerTime()
	{
		return serverTime;
	}

	private void FirstPlayerUpdate()
	{
		if (SteamManager.Initialized && socket.Instance.IsConnected() && !isFirstUpdate)
		{
			UpdatePlayerData();
		}
	}

	public void UpdatePlayerData()
	{
		if (SteamManager.Initialized && socket.Instance.IsConnected() && GameManager.Instance._playerData.currentPlayerProfileIndex != -1)
		{
			PlayerData playerData = new PlayerData();
			playerData.PROFILE_INDEX = GameManager.Instance._playerData.currentPlayerProfileIndex;
			playerData.PLAYER_ID = SteamUser.GetSteamID().m_SteamID.ToString();
			playerData.PLAYER_NAME = userData.DisplayName;
			playerData.PLAYER_PROFILE_NAME = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerName;
			playerData.GAME_VERSION = Application.version;
			playerData.PLAYER_LEVEL = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLevel;
			playerData.COUNTRY = Application.systemLanguage.ToString();
			playerData.PLAYER_CASH = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerCash;
			playerData.TOTAL_FISH = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().TotalFish;
			playerData.TOTAL_FISH_WEIGHT = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().TotalFishWeight;
			EmitWithID("UPDATE_PLAYER_DATA", JsonUtility.ToJson(playerData), dataIsPlainText: false);
			isFirstUpdate = true;
		}
	}

	private void OnGetBannedPlayer(string data)
	{
		if (JObject.Parse(data)["isBanned"].ToString() == "yes")
		{
			isBanned = true;
		}
		else
		{
			isBanned = false;
		}
		Debug.Log("isBanned: " + isBanned);
	}

	public void AddFishToRankings(GameManager.FishSpecies fishSpecies, float fishWeight, int points, int mapId)
	{
		int currentPlayerProfileIndex = GameManager.Instance._playerData.currentPlayerProfileIndex;
		rankingFishData.PLAYER_ID = SteamUser.GetSteamID().m_SteamID.ToString();
		rankingFishData.PLAYER_NAME = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerName;
		rankingFishData.PROFILE_INDEX = currentPlayerProfileIndex;
		rankingFishData.GAME_MODE = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().GameMode.ToString();
		rankingFishData.FISH_ID = (int)fishSpecies;
		rankingFishData.FISH_WEIGHT = fishWeight;
		rankingFishData.POINTS = points;
		rankingFishData.MAP_ID = mapId;
		EmitWithID("ADD_FISH_TO_RANKINGS", JsonUtility.ToJson(rankingFishData), dataIsPlainText: false);
	}

	public void GetRankingPlayers(int from, int to)
	{
		_ = GameManager.Instance._playerData.currentPlayerProfileIndex;
		getRankingsData.from = from;
		getRankingsData.to = to;
		getRankingsData.GAME_MODE = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().GameMode.ToString();
		EmitWithID("GET_RANKINGS_PLAYERS", JsonUtility.ToJson(getRankingsData), dataIsPlainText: false);
	}

	public void GetOwnRankingPosition()
	{
		int currentPlayerProfileIndex = GameManager.Instance._playerData.currentPlayerProfileIndex;
		RankingOwnData rankingOwnData = new RankingOwnData();
		rankingOwnData.PLAYER_ID = SteamUser.GetSteamID().m_SteamID.ToString();
		rankingOwnData.PROFILE_INDEX = currentPlayerProfileIndex;
		rankingOwnData.GAME_MODE = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().GameMode.ToString();
		EmitWithID("GET_RANKINGS_OWN", JsonUtility.ToJson(rankingOwnData), dataIsPlainText: false);
	}

	private void OnGetPlayersRanking(string data)
	{
		RankingPlayersData[] collection = JsonHelper.FromJson<RankingPlayersData>(JsonHelper.fixJson(data));
		rankingPlayersData.Clear();
		rankingPlayersData.AddRange(collection);
		UnityEngine.Object.FindObjectOfType<RankingManager>().ShowRankingData(rankingPlayersData);
	}

	private void OnGetOwnRanking(string data)
	{
		rankingOwnData = JsonUtility.FromJson<GetRankingOwnData>(data);
		UnityEngine.Object.FindObjectOfType<RankingManager>().ShowOwnRankingData(rankingOwnData);
	}

	public void GetRankingPlayersLocation(int from, int to, int locationID)
	{
		_ = GameManager.Instance._playerData.currentPlayerProfileIndex;
		getRankingsLocationData.from = from;
		getRankingsLocationData.to = to;
		getRankingsLocationData.locationID = locationID;
		getRankingsLocationData.GAME_MODE = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().GameMode.ToString();
		EmitWithID("GET_RANKINGS_LOCATION_PLAYERS", JsonUtility.ToJson(getRankingsLocationData), dataIsPlainText: false);
	}

	public void GetOwnRankingPositionLocation(int locationID)
	{
		int currentPlayerProfileIndex = GameManager.Instance._playerData.currentPlayerProfileIndex;
		RankingOwnLocationData rankingOwnLocationData = new RankingOwnLocationData();
		rankingOwnLocationData.PLAYER_ID = SteamUser.GetSteamID().m_SteamID.ToString();
		rankingOwnLocationData.PROFILE_INDEX = currentPlayerProfileIndex;
		rankingOwnLocationData.GAME_MODE = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().GameMode.ToString();
		rankingOwnLocationData.locationID = locationID;
		EmitWithID("GET_RANKINGS_LOCATION_OWN", JsonUtility.ToJson(rankingOwnLocationData), dataIsPlainText: false);
	}

	private void OnGetPlayersRankingLocation(string data)
	{
		RankingPlayersLocationData[] collection = JsonHelper.FromJson<RankingPlayersLocationData>(JsonHelper.fixJson(data));
		rankingPlayersLocationData.Clear();
		rankingPlayersLocationData.AddRange(collection);
		UnityEngine.Object.FindObjectOfType<RankingManager>().ShowRankingLocationData(rankingPlayersLocationData);
	}

	private void OnGetOwnRankingLocation(string data)
	{
		rankingOwnLocationData = JsonUtility.FromJson<GetRankingOwnLocationData>(data);
		UnityEngine.Object.FindObjectOfType<RankingManager>().ShowOwnRankingLocationData(rankingOwnLocationData);
	}

	private void TestAddPlayerChat()
	{
		_ = GameManager.Instance._playerData.currentPlayerProfileIndex;
		playerChatData.PLAYER_ID = UnityEngine.Random.Range(100000, 9999999).ToString();
		playerChatData.PLAYER_NAME = "Gracz_" + playerChatData.PLAYER_ID;
		playerChatData.COUNTRY = LocalizationManager.CurrentLanguageCode;
		playerChatData.LOCATION_ID = "0";
	}

	private void PlayerReconnect()
	{
		if (getPlayerChatRoomData.ID != "" && playerChatData.LOCATION_ID != "-1")
		{
			ReJoinToChat();
		}
	}

	public void JoinToChat(string locationId, ChatManager currentChat)
	{
		chatManager = currentChat;
		_ = GameManager.Instance._playerData.currentPlayerProfileIndex;
		playerChatData.PLAYER_ID = SteamUser.GetSteamID().m_SteamID.ToString();
		playerChatData.PLAYER_NAME = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerName;
		playerChatData.COUNTRY = LocalizationManager.CurrentLanguageCode;
		playerChatData.LOCATION_ID = locationId;
	}

	private void ReJoinToChat()
	{
		_ = GameManager.Instance._playerData.currentPlayerProfileIndex;
		new ReconnectPlayerData
		{
			PLAYER_ID = SteamUser.GetSteamID().m_SteamID.ToString(),
			PLAYER_NAME = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerName,
			ROOM_ID = getPlayerChatRoomData.ID,
			LOCATION_ID = getPlayerChatRoomData.LOCATION_ID
		};
	}

	public void SendChatMessage(string message, string country)
	{
		_ = GameManager.Instance._playerData.currentPlayerProfileIndex;
		new Message
		{
			PLAYER_ID = SteamUser.GetSteamID().m_SteamID.ToString(),
			PLAYER_NAME = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerName,
			COUNTRY = country,
			MESSAGE = message
		};
	}

	public void OnGetMessage(string data)
	{
		Message message = new Message();
		message = JsonUtility.FromJson<Message>(data);
		Debug.Log("data: " + data + " playerChatMessage:" + message.PLAYER_NAME);
	}

	private void OnGetChatJoinToRoom(string data)
	{
		getPlayerChatRoomData = JsonUtility.FromJson<GetPlayerChatRoomData>(data);
	}

	private void OnGetPlayerJoinToRoom(string data)
	{
		Message message = new Message();
		message = JsonUtility.FromJson<Message>(data);
		Debug.Log("data: " + data + " playerChatMessage:" + message.PLAYER_NAME);
	}

	private void OnLeavePlayerFromRoom(string data)
	{
		Message message = new Message();
		message = JsonUtility.FromJson<Message>(data);
		Debug.Log("Gracz wyszed³ z pokoju data: " + data + " playerChatMessage:" + message.PLAYER_NAME);
	}

	private void OnGetFishMessage(string data)
	{
		FishMessage fishMessage = new FishMessage();
		fishMessage = JsonUtility.FromJson<FishMessage>(data);
		Debug.Log("Gracz zlapal rybe: " + fishMessage.FISH_ID + " weight: " + fishMessage.FISH_WEIGHT);
	}

	public void ChatDisconnect()
	{
		getPlayerChatRoomData.ID = "";
		getPlayerChatRoomData.LOCATION_ID = "-1";
		getPlayerChatRoomData.PLAYERS = "";
	}

	private void OnGetOwnRewards(string data)
	{
		GetRewardOwnData[] collection = JsonHelper.FromJson<GetRewardOwnData>(JsonHelper.fixJson(data));
		rewardsOwnData.Clear();
		rewardsOwnData.AddRange(collection);
	}

	public void GetOwnRewards()
	{
		RewardOwnData rewardOwnData = new RewardOwnData();
		int currentPlayerProfileIndex = GameManager.Instance._playerData.currentPlayerProfileIndex;
		rewardOwnData.PLAYER_ID = SteamUser.GetSteamID().m_SteamID.ToString();
		rewardOwnData.PLAYER_NAME = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerName;
		rewardOwnData.PROFILE_INDEX = currentPlayerProfileIndex;
		EmitWithID("GET_REWARDS_OWN", JsonUtility.ToJson(rewardOwnData), dataIsPlainText: false);
	}

	public void GetAllTournaments()
	{
		socket.Instance.Emit("GET_TOURNAMENTS");
	}

	public void GetTournament(int tournamentId)
	{
		Debug.Log("Get tournament emit");
		EmitWithID("GET_TOURNAMENT", tournamentId.ToString(), dataIsPlainText: false);
	}

	private void OnGetTournaments(string data)
	{
		TournamentData[] array = JsonHelper.FromJson<TournamentData>(JsonHelper.fixJson(data));
		for (int i = 0; i < array.Length; i++)
		{
			bool flag = false;
			for (int j = 0; j < TournamentManager.Instance.tournaments.Count; j++)
			{
				if (TournamentManager.Instance.tournaments[j].id == array[i].ID)
				{
					TournamentManager.Instance.tournaments[j].timeToEnd = array[i].TIME_TO_END_S;
					TournamentManager.Instance.tournaments[j].timeLeft = (int)((array[i].TIME_START + array[i].DURATION * 60 - serverTime) / 60);
					TournamentManager.Instance.tournaments[j].timeStart = array[i].TIME_START;
					TournamentManager.Instance.tournaments[j].timeCreate = array[i].TIME_CREATE_S;
					flag = true;
				}
			}
			if (!flag)
			{
				TournamentManager.CTournament cTournament = new TournamentManager.CTournament();
				cTournament.id = array[i].ID;
				cTournament.tournamentName = array[i].NAME;
				cTournament.tournamentType = (TournamentManager.TournamentContentType)Enum.Parse(typeof(TournamentManager.TournamentContentType), array[i].TYPE);
				cTournament.type = (TournamentManager.TournamentType)Enum.Parse(typeof(TournamentManager.TournamentType), array[i].VISABLE_TYPE);
				cTournament.tournamentTask = (TournamentManager.CTournament.TournamentTask)Enum.Parse(typeof(TournamentManager.CTournament.TournamentTask), array[i].TASK);
				cTournament.tournamentMethod = (TournamentManager.CTournament.TournamentMethod)Enum.Parse(typeof(TournamentManager.CTournament.TournamentMethod), array[i].METHOD);
				cTournament.mapId = array[i].MAP_ID;
				cTournament.duration = array[i].DURATION;
				cTournament.participantMaximum = array[i].PARTICIPANTS_MAX;
				cTournament.entryFee = array[i].ENTRY_FEE;
				cTournament.levelRange = new Vector2(array[i].LEVEL_MIN, array[i].LEVEL_MAX);
				cTournament.timeStart = array[i].TIME_START;
				cTournament.creatorPlayerId = array[i].CREATOR_PLAYER_ID;
				cTournament.creatorPlayerName = array[i].CREATOR_PLAYER_NAME;
				cTournament.creatorProfileIndex = array[i].CREATOR_PROFILE_INDEX;
				cTournament.timeLeft = (int)((array[i].TIME_START + array[i].DURATION * 60 - serverTime) / 60);
				cTournament.timeToEnd = array[i].TIME_TO_END_S;
				cTournament.timeCreate = array[i].TIME_CREATE_S;
				TournamentManager.Instance.tournaments.Add(cTournament);
			}
		}
		for (int k = 0; k < TournamentManager.Instance.tournaments.Count; k++)
		{
			bool flag2 = true;
			for (int l = 0; l < array.Length; l++)
			{
				if (TournamentManager.Instance.tournaments[k].id == array[l].ID)
				{
					flag2 = false;
				}
			}
			if (flag2)
			{
				TournamentManager.Instance.tournaments.Remove(TournamentManager.Instance.tournaments[k]);
			}
		}
		Debug.Log("Odebrano liste turniejów z serwera: " + array.Length);
	}

	public void GetTournamentParticipants(int tournamentId)
	{
		EmitWithID("GET_TOURNAMENT_PARTICIPANTS", tournamentId.ToString(), dataIsPlainText: false);
	}

	private void OnGetTournamentParticipants(string data)
	{
		getParticipantReady = true;
		TournamentParticipantsData[] array = JsonHelper.FromJson<TournamentParticipantsData>(JsonHelper.fixJson(data));
		Debug.Log("Odebrano liste uczestników turniejów z serwera: " + array.Length);
		for (int i = 0; i < array.Length; i++)
		{
			for (int j = 0; j < TournamentManager.Instance.tournaments.Count; j++)
			{
				if (TournamentManager.Instance.tournaments[j].id != array[i].TOURNAMENT_ID)
				{
					continue;
				}
				bool flag = false;
				for (int k = 0; k < TournamentManager.Instance.tournaments[j].tournamentParticipants.Count; k++)
				{
					if (TournamentManager.Instance.tournaments[j].tournamentParticipants[k].playerId == array[i].PLAYER_ID && TournamentManager.Instance.tournaments[j].tournamentParticipants[k].profile_index == array[i].PROFILE_INDEX)
					{
						TournamentManager.Instance.tournaments[j].tournamentParticipants[k].player_level = array[i].PLAYER_LEVEL;
						TournamentManager.Instance.tournaments[j].tournamentParticipants[k].tournaments_won = array[i].TOURNAMENTS_WON;
						TournamentManager.Instance.tournaments[j].tournamentParticipants[k].rankings_points = array[i].RANKING_POINTS;
						TournamentManager.Instance.tournaments[j].tournamentParticipants[k].value = array[i].VALUE;
						TournamentManager.Instance.tournaments[j].tournamentParticipants[k].bestFishId = array[i].BEST_FISH_ID;
						TournamentManager.Instance.tournaments[j].tournamentParticipants[k].status = array[i].STATUS;
						TournamentManager.Instance.tournaments[j].tournamentParticipants[k].joined_timeleft = array[i].JOINED_TIMELEFT;
						flag = true;
					}
				}
				if (!flag)
				{
					TournamentManager.CTournament.TournamentParticipant tournamentParticipant = new TournamentManager.CTournament.TournamentParticipant();
					tournamentParticipant.playerId = array[i].PLAYER_ID;
					tournamentParticipant.playerName = array[i].PLAYER_NAME;
					tournamentParticipant.profile_index = array[i].PROFILE_INDEX;
					tournamentParticipant.player_level = array[i].PLAYER_LEVEL;
					tournamentParticipant.tournaments_won = array[i].TOURNAMENTS_WON;
					tournamentParticipant.rankings_points = array[i].RANKING_POINTS;
					tournamentParticipant.bestFishId = array[i].BEST_FISH_ID;
					tournamentParticipant.value = array[i].VALUE;
					tournamentParticipant.status = array[i].STATUS;
					tournamentParticipant.joined_timeleft = array[i].JOINED_TIMELEFT;
					TournamentManager.Instance.tournaments[j].tournamentParticipants.Add(tournamentParticipant);
				}
			}
		}
	}

	public void JoinToTournament(TournamentManager.CTournament tournament)
	{
		int currentPlayerProfileIndex = GameManager.Instance._playerData.currentPlayerProfileIndex;
		TournamentJoinData tournamentJoinData = new TournamentJoinData();
		tournamentJoinData.PLAYER_ID = SteamUser.GetSteamID().m_SteamID.ToString();
		tournamentJoinData.PLAYER_NAME = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerName;
		tournamentJoinData.PROFILE_INDEX = currentPlayerProfileIndex;
		tournamentJoinData.TOURNAMENT_ID = tournament.id;
		tournamentJoinData.PARTICIPANTS_MAX = tournament.participantMaximum;
		tournamentJoinData.PLAYER_LEVEL = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLevel;
		tournamentJoinData.TOURNAMENTS_WON = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerTournamentsWon;
		tournamentJoinData.RANKING_POINTS = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRankingPoints;
		EmitWithID("JOIN_TOURNAMENT", JsonUtility.ToJson(tournamentJoinData), dataIsPlainText: false);
	}

	private void OnJoinTournamentFailed(string data)
	{
		Debug.Log("B³¹d do³aczenia, limit uczestników");
	}

	private void OnJoinTournamentSuccess(string data)
	{
		Debug.Log("Do³aczenie do turnieju: " + data);
		if (int.TryParse(data, out var result))
		{
			TournamentManager.Instance.myTournamentsIds.Add(result);
		}
	}

	public void GetTournamentJoinedIds()
	{
		int currentPlayerProfileIndex = GameManager.Instance._playerData.currentPlayerProfileIndex;
		TournamentJoinData tournamentJoinData = new TournamentJoinData();
		tournamentJoinData.PLAYER_ID = SteamUser.GetSteamID().m_SteamID.ToString();
		tournamentJoinData.PROFILE_INDEX = currentPlayerProfileIndex;
		EmitWithID("GET_JOINED_TOURNAMENT_IDS", JsonUtility.ToJson(tournamentJoinData), dataIsPlainText: false);
	}

	private void OnGetTournamentJoinedIds(string data)
	{
		Debug.Log("OnGetTournamentJoinedIds: " + data);
		TournamentJoinedIdsData[] array = JsonHelper.FromJson<TournamentJoinedIdsData>(JsonHelper.fixJson(data));
		TournamentManager.Instance.myTournamentsIds.Clear();
		for (int i = 0; i < array.Length; i++)
		{
			TournamentManager.Instance.myTournamentsIds.Add(array[i].TOURNAMENT_ID);
		}
	}

	public void CreateTournament(TournamentManager.CTournament tournament, List<TournamentManager.CInviteSend> invitePlayers)
	{
		int currentPlayerProfileIndex = GameManager.Instance._playerData.currentPlayerProfileIndex;
		TournamentCreatorData tournamentCreatorData = new TournamentCreatorData();
		tournamentCreatorData.NAME = tournament.tournamentName;
		tournamentCreatorData.TYPE = tournament.tournamentType.ToString();
		tournamentCreatorData.TYPE_PLAYER_TOURNAMENT = tournament.type.ToString();
		tournamentCreatorData.TASK = tournament.tournamentTask.ToString();
		tournamentCreatorData.METHOD = tournament.tournamentMethod.ToString();
		tournamentCreatorData.MAP_ID = tournament.mapId;
		tournamentCreatorData.DURATION = tournament.duration;
		tournamentCreatorData.ENTRY_FEE = tournament.entryFee;
		tournamentCreatorData.PARTICIPANTS_MAX = tournament.participantMaximum;
		tournamentCreatorData.LEVEL_MIN = (int)tournament.levelRange.x;
		tournamentCreatorData.LEVEL_MAX = (int)tournament.levelRange.y;
		tournamentCreatorData.PLAYER_ID = SteamUser.GetSteamID().m_SteamID.ToString();
		tournamentCreatorData.PLAYER_NAME = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerName;
		tournamentCreatorData.PROFILE_INDEX = currentPlayerProfileIndex;
		tournamentCreatorData.INVITES = JsonHelper.ToJson(invitePlayers.ToArray());
		EmitWithID("CREATE_TOURNAMENT", JsonUtility.ToJson(tournamentCreatorData), dataIsPlainText: false);
	}

	private void OnCreateTournament(string data)
	{
		if (int.TryParse(data, out var result) && result != -1)
		{
			TournamentManager.Instance.currentCreatorTournament.id = result;
			TournamentPlayerCreator tournamentPlayerCreator = UnityEngine.Object.FindObjectOfType<TournamentPlayerCreator>();
			if (tournamentPlayerCreator != null)
			{
				Debug.Log("Create tournament id:" + result);
				tournamentPlayerCreator.CreateSuccess();
			}
		}
	}

	public void ReadyTournament(TournamentManager.CTournament tournament)
	{
		int currentPlayerProfileIndex = GameManager.Instance._playerData.currentPlayerProfileIndex;
		TournamentJoinData tournamentJoinData = new TournamentJoinData();
		tournamentJoinData.PLAYER_ID = SteamUser.GetSteamID().m_SteamID.ToString();
		tournamentJoinData.PROFILE_INDEX = currentPlayerProfileIndex;
		tournamentJoinData.TOURNAMENT_ID = tournament.id;
		EmitWithID("READY_TOURNAMENT", JsonUtility.ToJson(tournamentJoinData), dataIsPlainText: false);
	}

	public void AutoReadyTournament(TournamentManager.CTournament.TournamentParticipant participant, int tournament_id)
	{
		TournamentJoinData tournamentJoinData = new TournamentJoinData();
		tournamentJoinData.PLAYER_ID = participant.playerId;
		tournamentJoinData.PROFILE_INDEX = participant.profile_index;
		tournamentJoinData.TOURNAMENT_ID = tournament_id;
		EmitWithID("READY_TOURNAMENT", JsonUtility.ToJson(tournamentJoinData), dataIsPlainText: false);
	}

	public void GetTournamentInvites()
	{
		TournamentJoinData tournamentJoinData = new TournamentJoinData();
		tournamentJoinData.PLAYER_ID = SteamUser.GetSteamID().m_SteamID.ToString();
		EmitWithID("GET_INVITES_TOURNAMENT", JsonUtility.ToJson(tournamentJoinData), dataIsPlainText: false);
	}

	private void OnGetTournamentInvites(string data)
	{
		TournamentInvitesData[] array = JsonHelper.FromJson<TournamentInvitesData>(JsonHelper.fixJson(data));
		for (int i = 0; i < array.Length; i++)
		{
			bool flag = false;
			for (int j = 0; j < TournamentManager.Instance.myTournamentInvites.Count; j++)
			{
				if (TournamentManager.Instance.myTournamentInvites[j].tournamentId == array[i].TOURNAMENT_ID)
				{
					flag = true;
				}
			}
			if (!flag)
			{
				TournamentManager.CInvite cInvite = new TournamentManager.CInvite();
				cInvite.tournamentId = array[i].TOURNAMENT_ID;
				cInvite.tournamentName = array[i].TOURNAMENT_NAME;
				cInvite.playerSenderName = array[i].SEND_PLAYER_NAME;
				TournamentManager.Instance.myTournamentInvites.Add(cInvite);
			}
		}
		for (int k = 0; k < TournamentManager.Instance.myTournamentInvites.Count; k++)
		{
			bool flag2 = false;
			for (int l = 0; l < array.Length; l++)
			{
				if (TournamentManager.Instance.myTournamentInvites[k].tournamentId == array[l].TOURNAMENT_ID)
				{
					flag2 = true;
				}
			}
			if (!flag2)
			{
				TournamentManager.Instance.myTournamentInvites.Remove(TournamentManager.Instance.myTournamentInvites[k]);
			}
		}
	}

	public void StartPlayerTournament(int tournamentId)
	{
		TournamentJoinedIdsData tournamentJoinedIdsData = new TournamentJoinedIdsData();
		tournamentJoinedIdsData.TOURNAMENT_ID = tournamentId;
		EmitWithID("START_TOURNAMENT", JsonUtility.ToJson(tournamentJoinedIdsData), dataIsPlainText: false);
	}

	public void TournamentSendFish(int fishId, float weight, TournamentManager.CTournament tournament, int mapId = 0)
	{
		TournamentFishData tournamentFishData = new TournamentFishData();
		tournamentFishData.TOURNAMENT_ID = tournament.id;
		tournamentFishData.PLAYER_ID = SteamUser.GetSteamID().m_SteamID.ToString();
		tournamentFishData.PROFILE_INDEX = GameManager.Instance._playerData.currentPlayerProfileIndex;
		tournamentFishData.TASK = tournament.tournamentTask.ToString();
		tournamentFishData.FISH_ID = fishId;
		tournamentFishData.FISH_WEIGHT = weight;
		tournamentFishData.MAP_ID = mapId;
		EmitWithID("ADD_FISH_TOURNAMENT", JsonUtility.ToJson(tournamentFishData), dataIsPlainText: false);
	}

	public void TournamentSendFishTESt(int fishId, float weight, int tournamentID)
	{
		TournamentFishData tournamentFishData = new TournamentFishData();
		tournamentFishData.TOURNAMENT_ID = tournamentID;
		tournamentFishData.PLAYER_ID = SteamUser.GetSteamID().m_SteamID.ToString();
		tournamentFishData.PROFILE_INDEX = GameManager.Instance._playerData.currentPlayerProfileIndex;
		tournamentFishData.FISH_ID = fishId;
		tournamentFishData.FISH_WEIGHT = weight;
		EmitWithID("ADD_FISH_TOURNAMENT", JsonUtility.ToJson(tournamentFishData), dataIsPlainText: false);
	}

	public void DeletePlayerTournament(int tournamentId)
	{
		TournamentJoinedIdsData tournamentJoinedIdsData = new TournamentJoinedIdsData();
		tournamentJoinedIdsData.TOURNAMENT_ID = tournamentId;
		EmitWithID("DELETE_TOURNAMENT", JsonUtility.ToJson(tournamentJoinedIdsData), dataIsPlainText: false);
	}

	private void OnGetTournamentDeleteByPlayer()
	{
		TournamentScene tournamentScene = UnityEngine.Object.FindObjectOfType<TournamentScene>();
		if ((bool)tournamentScene)
		{
			TournamentManager.Instance.tournaments.Clear();
			if (tournamentScene.currentTournamentContentType == TournamentManager.TournamentContentType.CreatorTournament)
			{
				tournamentScene.ChangeType("CreatorTournament");
			}
			if (tournamentScene.currentTournamentContentType == TournamentManager.TournamentContentType.MyTournaments)
			{
				tournamentScene.ChangeType("MyTournaments");
			}
			if (tournamentScene.currentTournamentContentType == TournamentManager.TournamentContentType.Players)
			{
				tournamentScene.ChangeType("Players");
			}
		}
	}

	private void TestServerResponse(string eventName, string payload)
	{
		testServerEventNameLast = eventName;
		testServerResponseLast = payload;
	}

	private void ResetResponse()
	{
		testServerWasTimeout = false;
		testServerEventNameLast = null;
		testServerResponseLast = null;
	}

	private IEnumerator WaitForResponseOrTimeout(bool filterOut_Time = true, bool filterOut_Rewards = true, bool filterOut_Invites = true)
	{
		testServerWasTimeout = false;
		float timeout = 5f;
		float startTime = Time.time;
		while (Time.time - startTime < timeout)
		{
			if (testServerEventNameLast != null)
			{
				bool flag = false;
				if (filterOut_Time && testServerEventNameLast == "ON_GET_SERVER_TIME")
				{
					flag = true;
				}
				if (filterOut_Rewards && testServerEventNameLast == "ON_GET_REWARDS_OWN")
				{
					flag = true;
				}
				if (filterOut_Invites && testServerEventNameLast == "ON_GET_TOURNAMENT_INVITES")
				{
					flag = true;
				}
				if (!flag)
				{
					yield break;
				}
			}
			yield return null;
		}
		testServerWasTimeout = true;
	}

	public void StartAPITest(TextMeshProUGUI uiText)
	{
		if (!apiTestRunning)
		{
			apiTestStage = (APITestStage)((int)(apiTestStage + 1) % Enum.GetValues(typeof(APITestStage)).Length);
			if (apiTestStage == APITestStage.None)
			{
				UnityEngine.Object.Destroy(uiText.transform.parent.gameObject);
			}
			else
			{
				StartCoroutine(TestCoroutine());
			}
		}
		IEnumerator TestCoroutine()
		{
			apiTestRunning = true;
			uiText.text = "";
			uiText.text += $"Socket status: {socket.Instance.Status}\n";
			TextMeshProUGUI textMeshProUGUI = uiText;
			textMeshProUGUI.text = textMeshProUGUI.text + "Socket socket ID: " + socket.Instance.SocketID + "\n";
			TextMeshProUGUI textMeshProUGUI2 = uiText;
			textMeshProUGUI2.text = textMeshProUGUI2.text + "Socket address: " + socket.socketIOAddress + "\n";
			uiText.text += "\n//////////////////////////////////////////////////////////////////////////////\n\n";
			using (System.Net.NetworkInformation.Ping ping = new System.Net.NetworkInformation.Ping())
			{
				string text = socket.socketIOAddress.Split(':')[0];
				try
				{
					PingReply pingReply = ping.Send(text);
					if (pingReply.Status == IPStatus.Success)
					{
						uiText.text += $"Ping to {pingReply.Address} successful: Time={pingReply.RoundtripTime}ms\n";
					}
					else
					{
						uiText.text += $"Ping to {pingReply.Address} failed: {pingReply.Status}\n";
					}
				}
				catch (Exception ex)
				{
					TextMeshProUGUI textMeshProUGUI3 = uiText;
					textMeshProUGUI3.text = textMeshProUGUI3.text + "Failed to ping " + text + ": " + ex.Message + "\n";
				}
			}
			uiText.text += $"\n/////////////////////////////////////     API TEST STAGE: {apiTestStage}     /////////////////////////////////////////\n\n";
			if (apiTestStage == APITestStage.RewardsAndOwnRanking)
			{
				uiText.text += "\nEmitting event: GET_REWARDS_OWN\n";
				ResetResponse();
				GetOwnRewards();
				yield return WaitForResponseOrTimeout(filterOut_Time: true, filterOut_Rewards: false);
				if (!testServerWasTimeout)
				{
					TextMeshProUGUI textMeshProUGUI3 = uiText;
					textMeshProUGUI3.text = textMeshProUGUI3.text + "Received response for " + testServerEventNameLast + ": " + testServerResponseLast + "\n";
				}
				else
				{
					uiText.text += "Response timeout\n";
				}
				uiText.text += "\nEmitting event: GET_RANKINGS_OWN\n";
				ResetResponse();
				GetOwnRankingPosition();
				yield return WaitForResponseOrTimeout();
				if (!testServerWasTimeout)
				{
					TextMeshProUGUI textMeshProUGUI3 = uiText;
					textMeshProUGUI3.text = textMeshProUGUI3.text + "Received response for " + testServerEventNameLast + ": " + testServerResponseLast + "\n";
				}
				else
				{
					uiText.text += "Response timeout\n";
				}
				uiText.text += "\nEmitting event: GET_RANKINGS_LOCATION_OWN\n";
				ResetResponse();
				GetOwnRankingPositionLocation(2);
				yield return WaitForResponseOrTimeout();
				if (!testServerWasTimeout)
				{
					TextMeshProUGUI textMeshProUGUI3 = uiText;
					textMeshProUGUI3.text = textMeshProUGUI3.text + "Received response for " + testServerEventNameLast + ": " + testServerResponseLast + "\n";
				}
				else
				{
					uiText.text += "Response timeout\n";
				}
				uiText.text += "\nEmitting event: ADD_FISH_TO_RANKINGS\n";
				List<int> list = new List<int> { 2 };
				int num = list[UnityEngine.Random.Range(0, list.Count)];
				GameManager.FishSpecies fishSpecies = GameManager.FishSpecies.Perch;
				float num2 = 1f;
				int num3 = 1;
				switch (num)
				{
				case 0:
					fishSpecies = GameManager.FishSpecies.Bluegill;
					num2 = 0.7966322f;
					num3 = 4;
					break;
				case 1:
					fishSpecies = GameManager.FishSpecies.Asp;
					num2 = 1.2f;
					num3 = 5;
					break;
				case 2:
					fishSpecies = GameManager.FishSpecies.CharArctic;
					num2 = 1.2f;
					num3 = 5;
					break;
				case 3:
					fishSpecies = GameManager.FishSpecies.Tench;
					num2 = 1.2f;
					num3 = 5;
					break;
				case 4:
					fishSpecies = GameManager.FishSpecies.Tench;
					num2 = 1.2f;
					num3 = 5;
					break;
				}
				uiText.text += $"Fish: {fishSpecies}     Weight: {num2}     Points: {num3}      Map ID: {num}\n";
				ResetResponse();
				AddFishToRankings(fishSpecies, num2, num3, num);
				yield return WaitForResponseOrTimeout();
				if (!testServerWasTimeout)
				{
					TextMeshProUGUI textMeshProUGUI3 = uiText;
					textMeshProUGUI3.text = textMeshProUGUI3.text + "Received response for " + testServerEventNameLast + ": " + testServerResponseLast + "\n";
				}
				else
				{
					uiText.text += "Response timeout\n";
				}
			}
			if (apiTestStage == APITestStage.ServerTime)
			{
				uiText.text += "\nEmitting event: GET_TIME_FROM_SERVER\n";
				ResetResponse();
				RepeatTime();
				yield return WaitForResponseOrTimeout(filterOut_Time: false);
				if (!testServerWasTimeout)
				{
					TextMeshProUGUI textMeshProUGUI3 = uiText;
					textMeshProUGUI3.text = textMeshProUGUI3.text + "Received response for " + testServerEventNameLast + ": " + testServerResponseLast + "\n";
				}
				else
				{
					uiText.text += "Response timeout\n";
				}
			}
			if (apiTestStage == APITestStage.OtherPlayersRanking)
			{
				uiText.text += "\nEmitting event: GET_RANKINGS_PLAYERS\n";
				ResetResponse();
				GetRankingPlayers(15, 0);
				yield return WaitForResponseOrTimeout();
				if (!testServerWasTimeout)
				{
					TextMeshProUGUI textMeshProUGUI3 = uiText;
					textMeshProUGUI3.text = textMeshProUGUI3.text + "Received response for " + testServerEventNameLast + ": " + testServerResponseLast + "\n";
				}
				else
				{
					uiText.text += "Response timeout\n";
				}
				uiText.text += "\nEmitting event: GET_RANKINGS_LOCATION_PLAYERS\n";
				ResetResponse();
				GetRankingPlayersLocation(15, 0, 2);
				yield return WaitForResponseOrTimeout();
				if (!testServerWasTimeout)
				{
					TextMeshProUGUI textMeshProUGUI3 = uiText;
					textMeshProUGUI3.text = textMeshProUGUI3.text + "Received response for " + testServerEventNameLast + ": " + testServerResponseLast + "\n";
				}
				else
				{
					uiText.text += "Response timeout\n";
				}
			}
			if (apiTestStage == APITestStage.UpdatePlayerData)
			{
				uiText.text += "\nEmitting event: UPDATE_PLAYER_DATA\n";
				ResetResponse();
				UpdatePlayerData();
				yield return WaitForResponseOrTimeout();
				if (!testServerWasTimeout)
				{
					TextMeshProUGUI textMeshProUGUI3 = uiText;
					textMeshProUGUI3.text = textMeshProUGUI3.text + "Received response for " + testServerEventNameLast + ": " + testServerResponseLast + "\n";
				}
				else
				{
					uiText.text += "Response timeout\n";
				}
			}
			if (apiTestStage == APITestStage.Tournaments_0)
			{
				uiText.text += "\nEmitting event: GET_TOURNAMENTS\n";
				ResetResponse();
				GetAllTournaments();
				yield return WaitForResponseOrTimeout();
				if (!testServerWasTimeout)
				{
					TextMeshProUGUI textMeshProUGUI3 = uiText;
					textMeshProUGUI3.text = textMeshProUGUI3.text + "Received response for " + testServerEventNameLast + ": " + testServerResponseLast + "\n";
				}
				else
				{
					uiText.text += "Response timeout\n";
				}
				uiText.text += "\nEmitting event: GET_JOINED_TOURNAMENT_IDS\n";
				ResetResponse();
				GetTournamentJoinedIds();
				yield return WaitForResponseOrTimeout();
				if (!testServerWasTimeout)
				{
					TextMeshProUGUI textMeshProUGUI3 = uiText;
					textMeshProUGUI3.text = textMeshProUGUI3.text + "Received response for " + testServerEventNameLast + ": " + testServerResponseLast + "\n";
				}
				else
				{
					uiText.text += "Response timeout\n";
				}
				uiText.text += "\nEmitting event: GET_INVITES_TOURNAMENT\n";
				ResetResponse();
				GetTournamentInvites();
				yield return WaitForResponseOrTimeout(filterOut_Time: true, filterOut_Rewards: true, filterOut_Invites: false);
				if (!testServerWasTimeout)
				{
					TextMeshProUGUI textMeshProUGUI3 = uiText;
					textMeshProUGUI3.text = textMeshProUGUI3.text + "Received response for " + testServerEventNameLast + ": " + testServerResponseLast + "\n";
				}
				else
				{
					uiText.text += "Response timeout\n";
				}
			}
			string path = $"ServerAPITest_Stage_{apiTestStage}.txt";
			using (StreamWriter streamWriter = new StreamWriter(Path.Combine(Application.persistentDataPath, path), append: false))
			{
				streamWriter.Write(uiText.text);
			}
			yield return new WaitForSeconds(1f);
			uiText.text += "\n/////////////////////////////////////     API TEST DONE     /////////////////////////////////////////\n\n";
			apiTestRunning = false;
		}
	}

	private void EmitWithID(string eventName, string jsonData, bool dataIsPlainText)
	{
		string text = jsonData;
		try
		{
			JObject jObject = JObject.Parse(jsonData);
			jObject["SOC_EV_ID"] = socketEventID;
			text = jObject.ToString(Formatting.None);
		}
		catch
		{
			text = jsonData;
		}
		socket.Instance.Emit(eventName, text, dataIsPlainText);
		socketEventID++;
		if (socketEventID >= 10000)
		{
			socketEventID = 0;
		}
	}
}