using System;
using System.Collections.Generic;
using BitStrap;
using CodeStage.AntiCheat.ObscuredTypes;
using Steamworks;
using UnityEngine;

public class SteamStatsManager : MonoBehaviour
{
	public enum UserState
	{
		OFFLINE = 0,
		BUSY = 1,
		ONLINE = 2
	}

	[Serializable]
	public class SteamUser
	{
		public ulong platformProfileID;

		public string friendName = string.Empty;

		public UserState userState;

		public Texture2D avatarSmall;

		public Texture2D avatarMedium;

		public Texture2D avatarLarge;

		public CSteamID steamId;

		[Space(10f)]
		public int score;

		public int level = 1;

		public int experience;

		public int totalFishCount;

		public int totalFishWeight;

		public int biggestFishSpecies = -1;

		public int biggestFishWeight = -1;

		[Space(10f)]
		public ObscuredInt tournamentTrophyGold = 0;

		public ObscuredInt tournamentTrophySilver = 0;

		public ObscuredInt tournamentTrophyBronze = 0;

		[Space(10f)]
		public ObscuredInt tournamentTotalFishCount = 0;

		public ObscuredInt tournamentTotalFishWeight = 0;

		public ObscuredInt tournamentBiggestFishSpecies = -1;

		public ObscuredInt tournamentBiggestFishWeight = -1;

		public ObscuredInt tournamentCanGatherReward = 0;

		private void OnDestroy()
		{
		}
	}

	private static SteamStatsManager instance;

	public SteamUser mySteamUser = new SteamUser();

	public List<SteamUser> friendsList = new List<SteamUser>();

	public List<Color> stateColors = new List<Color>();

	public string inviteTestMsg = string.Empty;

	public int testInviteLevel;

	public int testInviteTournament;

	public string testInviteRoom = string.Empty;

	public PlayersGUI playersGUI;

	protected Callback<UserStatsReceived_t> onUserStatsReceived_t;

	protected CallResult<UserStatsReceived_t> onUserStatsReceivedResult_t;

	protected Callback<GameRichPresenceJoinRequested_t> onGameRichPresenceJoinRequested_t;

	public static SteamStatsManager Instance
	{
		get
		{
			return instance;
		}
	}

	private SteamStatsManager()
	{
	}

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

	private void OnEnable()
	{
		if (SteamManager.Initialized)
		{
			onUserStatsReceived_t = Callback<UserStatsReceived_t>.Create(OnUserStatsReceived);
			onUserStatsReceivedResult_t = CallResult<UserStatsReceived_t>.Create(OnUserStatsReceivedResult);
			onGameRichPresenceJoinRequested_t = Callback<GameRichPresenceJoinRequested_t>.Create(OnGameRichPresenceJoinRequested);
		}
	}

	private void Start()
	{
		if (SteamManager.Initialized)
		{
			SteamUserStats.RequestCurrentStats();
		}
		playersGUI = MenuManager.Instance.GetComponentInChildren<PlayersGUI>(true);
		InitializePlatformPlayer();
	}

	public void InitializePlatformPlayer()
	{
		mySteamUser = CreatePlatformUser(GlobalSettings.Instance.GetPlatformProfileID());
		mySteamUser.friendName = GlobalSettings.Instance.GetPlatformProfileName();
	}

	public SteamUser GetMySteamUser()
	{
		if (mySteamUser != null && mySteamUser.friendName == string.Empty)
		{
			return null;
		}
		return mySteamUser;
	}

	[Button]
	public void StoreStats()
	{
		GlobalSettings globalSettings = GlobalSettings.Instance;
		if (SteamManager.Initialized)
		{
			SteamUserStats.SetStat("SCORE", globalSettings.playerSettings.playersScore);
			SteamUserStats.SetStat("LEVEL", globalSettings.playerSettings.playersLevel);
			SteamUserStats.SetStat("EXPERIENCE", globalSettings.playerSettings.playersExperience);
			SteamUserStats.SetStat("TOTAL_FISH_COUNT", globalSettings.fishManager.GetTotalFishCount());
			SteamUserStats.SetStat("TOTAL_FISH_WEIGHT", Mathf.RoundToInt(globalSettings.fishManager.GetTotalFishWeight() * 1000f));
			FishManager.FishDefinition biggestFishDefinition = globalSettings.fishManager.GetBiggestFishDefinition();
			if (biggestFishDefinition == null)
			{
				SteamUserStats.SetStat("BIGGEST_FISH_SPECIES", -1);
				SteamUserStats.SetStat("BIGGEST_FISH_WEIGHT", -1);
			}
			else
			{
				SteamUserStats.SetStat("BIGGEST_FISH_SPECIES", (int)biggestFishDefinition.species);
				SteamUserStats.SetStat("BIGGEST_FISH_WEIGHT", Mathf.RoundToInt(biggestFishDefinition.weight * 1000f));
			}
			SteamUserStats.SetStat("TOURNAMENT_TROPHY_GOLD", mySteamUser.tournamentTrophyGold);
			SteamUserStats.SetStat("TOURNAMENT_TROPHY_SILVER", mySteamUser.tournamentTrophySilver);
			SteamUserStats.SetStat("TOURNAMENT_TROPHY_BRONZE", mySteamUser.tournamentTrophyBronze);
			SteamUserStats.SetStat("TOURNAMENT_TOTAL_FISH_COUNT", mySteamUser.tournamentTotalFishCount);
			SteamUserStats.SetStat("TOURNAMENT_TOTAL_FISH_WEIGHT", mySteamUser.tournamentTotalFishWeight);
			SteamUserStats.SetStat("TOURNAMENT_BIGGEST_FISH_SPECIES", mySteamUser.tournamentBiggestFishSpecies);
			SteamUserStats.SetStat("TOURNAMENT_BIGGEST_FISH_WEIGHT", mySteamUser.tournamentBiggestFishWeight);
			SteamUserStats.SetStat("TOURNAMENT_CAN_GATHER_REWARD", mySteamUser.tournamentCanGatherReward);
			SteamUserStats.StoreStats();
		}
	}

	public void ResetTournamentStats()
	{
		mySteamUser.tournamentTotalFishCount = 0;
		mySteamUser.tournamentTotalFishWeight = 0;
		mySteamUser.tournamentBiggestFishSpecies = -1;
		mySteamUser.tournamentBiggestFishWeight = -1;
		Debug.Log("ResetTournamentStats");
		StoreStats();
	}

	public void RequestUserInformation(SteamUser steamUser, bool nameOnly)
	{
		if (SteamManager.Initialized)
		{
			SteamFriends.RequestUserInformation(steamUser.steamId, nameOnly);
		}
	}

	public void RequestUserStats(SteamUser steamUser)
	{
		if (SteamManager.Initialized)
		{
			Debug.Log("RequestUserStats " + steamUser.platformProfileID);
			SteamAPICall_t hAPICall = SteamUserStats.RequestUserStats(steamUser.steamId);
			onUserStatsReceivedResult_t.Set(hAPICall);
		}
	}

	private void OnUserStatsReceived(UserStatsReceived_t pCallback)
	{
		Debug.Log(string.Concat("[", 1101, " - UserStatsReceived] - ", pCallback.m_nGameID, " -- ", pCallback.m_eResult, " -- ", pCallback.m_steamIDUser));
		if ((bool)MultiplayerManager.Instance)
		{
			MultiplayerManager.Instance.RefreshRemotePlayerSteamStats(pCallback.m_steamIDUser.m_SteamID);
		}
	}

	private void OnUserStatsReceivedResult(UserStatsReceived_t pCallback, bool bIOFailure)
	{
		Debug.Log(string.Concat("[", 1101, " - UserStatsReceivedResult] - ", pCallback.m_nGameID, " -- ", pCallback.m_eResult, " -- ", pCallback.m_steamIDUser));
	}

	public SteamUser CreatePlatformUser(ulong platformProfileId)
	{
		Debug.Log("CreatePlatformUser: " + platformProfileId);
		SteamUser steamUser = new SteamUser();
		steamUser.platformProfileID = platformProfileId;
		if (SteamManager.Initialized)
		{
			steamUser.steamId = new CSteamID(platformProfileId);
			steamUser.friendName = SteamFriends.GetFriendPersonaName(steamUser.steamId);
			if (SteamFriends.GetFriendRelationship(steamUser.steamId) == EFriendRelationship.k_EFriendRelationshipFriend)
			{
				steamUser.userState = GetUserStateSteam(SteamFriends.GetFriendPersonaState(steamUser.steamId));
			}
			else
			{
				steamUser.userState = UserState.ONLINE;
			}
			steamUser.avatarSmall = SteamUtilsTest.GetSteamImageAsTexture2D(SteamFriends.GetSmallFriendAvatar(steamUser.steamId));
			steamUser.avatarMedium = SteamUtilsTest.GetSteamImageAsTexture2D(SteamFriends.GetMediumFriendAvatar(steamUser.steamId));
			steamUser.avatarLarge = SteamUtilsTest.GetSteamImageAsTexture2D(SteamFriends.GetLargeFriendAvatar(steamUser.steamId));
			bool flag = false;
			flag = SteamUserStats.GetUserStat(steamUser.steamId, "SCORE", out steamUser.score);
			flag = SteamUserStats.GetUserStat(steamUser.steamId, "LEVEL", out steamUser.level);
			flag = SteamUserStats.GetUserStat(steamUser.steamId, "EXPERIENCE", out steamUser.experience);
			flag = SteamUserStats.GetUserStat(steamUser.steamId, "TOTAL_FISH_COUNT", out steamUser.totalFishCount);
			flag = SteamUserStats.GetUserStat(steamUser.steamId, "TOTAL_FISH_WEIGHT", out steamUser.totalFishWeight);
			flag = SteamUserStats.GetUserStat(steamUser.steamId, "BIGGEST_FISH_SPECIES", out steamUser.biggestFishSpecies);
			flag = SteamUserStats.GetUserStat(steamUser.steamId, "BIGGEST_FISH_WEIGHT", out steamUser.biggestFishWeight);
			int pData = 0;
			flag = SteamUserStats.GetUserStat(steamUser.steamId, "TOURNAMENT_TOTAL_FISH_COUNT", out pData);
			steamUser.tournamentTotalFishCount = pData;
			flag = SteamUserStats.GetUserStat(steamUser.steamId, "TOURNAMENT_TOTAL_FISH_WEIGHT", out pData);
			steamUser.tournamentTotalFishWeight = pData;
			flag = SteamUserStats.GetUserStat(steamUser.steamId, "TOURNAMENT_BIGGEST_FISH_SPECIES", out pData);
			steamUser.tournamentBiggestFishSpecies = pData;
			flag = SteamUserStats.GetUserStat(steamUser.steamId, "TOURNAMENT_BIGGEST_FISH_WEIGHT", out pData);
			steamUser.tournamentBiggestFishWeight = pData;
			flag = SteamUserStats.GetUserStat(steamUser.steamId, "TOURNAMENT_CAN_GATHER_REWARD", out pData);
			steamUser.tournamentCanGatherReward = pData;
			flag = SteamUserStats.GetUserStat(steamUser.steamId, "TOURNAMENT_TROPHY_GOLD", out pData);
			steamUser.tournamentTrophyGold = pData;
			flag = SteamUserStats.GetUserStat(steamUser.steamId, "TOURNAMENT_TROPHY_SILVER", out pData);
			steamUser.tournamentTrophySilver = pData;
			flag = SteamUserStats.GetUserStat(steamUser.steamId, "TOURNAMENT_TROPHY_BRONZE", out pData);
			steamUser.tournamentTrophyBronze = pData;
		}
		return steamUser;
	}

	public SteamUser FindUserWithId(ulong platformId)
	{
		if (platformId == mySteamUser.platformProfileID)
		{
			return mySteamUser;
		}
		for (int i = 0; i < friendsList.Count; i++)
		{
			if (friendsList[i].platformProfileID == platformId)
			{
				return friendsList[i];
			}
		}
		if ((bool)MultiplayerManager.Instance)
		{
			return MultiplayerManager.Instance.FindUserWithId(platformId);
		}
		Debug.LogError("FindUserWithId == null " + platformId);
		return null;
	}

	public void UpdateFriendsList()
	{
		friendsList.Clear();
		if (SteamManager.Initialized)
		{
			int friendCount = SteamFriends.GetFriendCount(EFriendFlags.k_EFriendFlagImmediate);
			Debug.Log("UpdateFriendsList " + friendCount + " Friends.");
			for (int i = 0; i < friendCount; i++)
			{
				CSteamID friendByIndex = SteamFriends.GetFriendByIndex(i, EFriendFlags.k_EFriendFlagImmediate);
				SteamUser steamUser = Instance.CreatePlatformUser(friendByIndex.m_SteamID);
				RequestUserStats(steamUser);
				friendsList.Add(steamUser);
			}
		}
	}

	public bool IsUserAFriend(SteamUser steamUser)
	{
		if (SteamManager.Initialized)
		{
			return SteamFriends.GetFriendRelationship(steamUser.steamId) == EFriendRelationship.k_EFriendRelationshipFriend;
		}
		return false;
	}

	public void ShowSteamUser(SteamUser steamUser)
	{
		if (SteamManager.Initialized)
		{
			SteamFriends.ActivateGameOverlayToUser("steamid", steamUser.steamId);
			FriendGameInfo_t pFriendGameInfo = default(FriendGameInfo_t);
			SteamFriends.GetFriendGamePlayed(steamUser.steamId, out pFriendGameInfo);
			Debug.Log(string.Concat("friendGameInfo ", pFriendGameInfo.m_gameID, " ", pFriendGameInfo.m_steamIDLobby, " ", pFriendGameInfo.m_unGameIP, " ", pFriendGameInfo.m_usGamePort, " ", pFriendGameInfo.m_usQueryPort));
			Debug.Log("friendRelationship " + SteamFriends.GetFriendRelationship(steamUser.steamId));
			SteamFriends.RequestFriendRichPresence(steamUser.steamId);
		}
	}

	public void AddFriend(SteamUser steamUser)
	{
		if (SteamManager.Initialized)
		{
			SteamFriends.ActivateGameOverlayToUser("friendadd", steamUser.steamId);
		}
	}

	public void InviteFriend(SteamUser steamUser)
	{
		if (PhotonNetwork.room != null)
		{
			string empty = string.Empty;
			empty += GameController.Instance.GetFisheryId();
			empty += "#";
			empty += ((!GameController.Instance.isTournament) ? "0" : "1");
			empty += "@";
			empty += PhotonNetwork.room.Name;
			if (SteamManager.Initialized)
			{
				bool flag = SteamFriends.InviteUserToGame(steamUser.steamId, empty);
				Debug.Log("InviteFriend " + SteamFriends.GetFriendPersonaName(steamUser.steamId) + " " + empty);
			}
		}
	}

	public void OnGameRichPresenceJoinRequested(GameRichPresenceJoinRequested_t pCallback)
	{
		Debug.Log("OnGameRichPresenceJoinRequested " + SteamFriends.GetFriendPersonaName(pCallback.m_steamIDFriend) + " -- " + pCallback.m_rgchConnect);
		ProcessInviteMessage(pCallback.m_rgchConnect);
	}

	public void ProcessInviteMessage(string message)
	{
		int num = message.IndexOf("#");
		if (num == -1)
		{
			Debug.LogError("InviteMsgSeparatorTest no separatorFishery");
			return;
		}
		string text = message.Substring(0, num);
		if (text.Length <= 0)
		{
			Debug.LogError("InviteMsgSeparatorTest no fisheryId");
			return;
		}
		int num2 = message.IndexOf("@");
		string s = "0";
		if (num2 == -1)
		{
			Debug.LogError("InviteMsgSeparatorTest no separatorGameType");
		}
		else
		{
			s = message.Substring(num2 - 1, 1);
			num = num2;
		}
		string text2 = message.Substring(num + 1, message.Length - num - 1);
		if (text2.Length <= 0)
		{
			Debug.LogError("InviteMsgSeparatorTest no roomName");
			return;
		}
		if (Application.isPlaying)
		{
			MenuManager.Instance.LoadInviteFishery(int.Parse(text), int.Parse(s), text2);
		}
		Debug.Log("fisheryId: " + int.Parse(text) + " isTournament: " + int.Parse(s) + " roomName: " + text2);
	}

	[Button]
	public void InviteMsgSeparatorTest()
	{
		ProcessInviteMessage(inviteTestMsg);
	}

	[Button]
	public void TestInvite()
	{
		MenuManager.Instance.LoadInviteFishery(testInviteLevel, testInviteTournament, testInviteRoom);
	}

	public static UserState GetUserStateSteam(EPersonaState state)
	{
		switch (state)
		{
		case EPersonaState.k_EPersonaStateOnline:
		case EPersonaState.k_EPersonaStateLookingToTrade:
		case EPersonaState.k_EPersonaStateLookingToPlay:
			return UserState.ONLINE;
		case EPersonaState.k_EPersonaStateBusy:
		case EPersonaState.k_EPersonaStateAway:
		case EPersonaState.k_EPersonaStateSnooze:
			return UserState.BUSY;
		default:
			return UserState.OFFLINE;
		}
	}

	public Color GetUserStateColor(SteamUser steamUser)
	{
		return stateColors[(int)steamUser.userState];
	}

	public void PhotonPlayerToSteamUser(SteamUser steamUser, PhotonPlayer photonPlayer)
	{
		steamUser.friendName = photonPlayer.NickName;
		steamUser.level = (photonPlayer.CustomProperties.ContainsKey("playersLevel") ? ((int)photonPlayer.CustomProperties["playersLevel"]) : 0);
		steamUser.score = (photonPlayer.CustomProperties.ContainsKey("playersScore") ? ((int)photonPlayer.CustomProperties["playersScore"]) : 0);
		steamUser.experience = (photonPlayer.CustomProperties.ContainsKey("playersExperience") ? ((int)photonPlayer.CustomProperties["playersExperience"]) : 0);
		steamUser.totalFishCount = (photonPlayer.CustomProperties.ContainsKey("totalFishCount") ? ((int)photonPlayer.CustomProperties["totalFishCount"]) : 0);
		steamUser.totalFishWeight = (photonPlayer.CustomProperties.ContainsKey("totalFishWeight") ? ((int)photonPlayer.CustomProperties["totalFishWeight"]) : 0);
		steamUser.biggestFishSpecies = ((!photonPlayer.CustomProperties.ContainsKey("biggestFishSpecies")) ? (-1) : ((int)photonPlayer.CustomProperties["biggestFishSpecies"]));
		steamUser.biggestFishWeight = ((!photonPlayer.CustomProperties.ContainsKey("biggestFishWeight")) ? (-1) : ((int)photonPlayer.CustomProperties["biggestFishWeight"]));
	}
}