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

public class LeaderboardsManager : MonoBehaviour
{
	[Serializable]
	public class LeaderboardPlayerStats
	{
		public string fisheryName = string.Empty;

		public ObscuredInt leaderboardLevel = -1;

		public ObscuredInt leaderboardExp = -1;

		public ObscuredInt leaderboardScore = -1;

		public ObscuredInt leaderboardTotalFishCount = -1;

		public ObscuredInt leaderboardTotalFishWeight = -1;

		public ObscuredInt leaderboardBiggestFishSpecies = -1;

		public ObscuredInt leaderboardBiggestFishWeight = -1;

		public ObscuredInt leaderboardBiggestFishLength = -1;

		public ObscuredInt leaderboardMonth = -1;

		public LeaderboardPlayerStats(string fName)
		{
			fisheryName = fName;
		}
	}

	public enum LeaderboardType
	{
		Score = 0,
		FishCount = 1,
		FishWeight = 2,
		BiggestWeight = 3,
		COUNT = 4
	}

	public enum LeaderboardStats
	{
		LEVEL = 0,
		EXP = 1,
		FISH_COUNT = 2,
		FISH_WEIGHT = 3,
		BIGGEST_SPECIES = 4,
		BIGGEST_WEIGHT = 5,
		SCORE = 6,
		COUNT = 7
	}

	private static LeaderboardsManager instance;

	public LeaderboardGUI leaderboardGUI;

	public const string mainLeaderboardName = ".MAIN.";

	public ObscuredInt isServerMonthOdd = -1;

	public ObscuredInt currentServerYear = -1;

	public ObscuredInt currentServerMonth = -1;

	public List<LeaderboardPlayerStats> allLeaderboardPlayerStats = new List<LeaderboardPlayerStats>();

	public List<LeaderboardSettings> leaderboardSettings = new List<LeaderboardSettings>();

	private GlobalSettings globalSettings;

	protected CallResult<LeaderboardFindResult_t> onTestLeaderboardFindResult_t;

	[Header("CreateAllLeaderboards")]
	public string createAllName = ".MAIN.";

	public int createAllYear = 2018;

	public int createAllMonth = 1;

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

	private LeaderboardsManager()
	{
	}

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

	private void Start()
	{
		globalSettings = GlobalSettings.Instance;
		if (!SteamManager.Initialized)
		{
			return;
		}
		DLCManager.Instance.ListAllDLCSettings();
		CreateLeaderboardPlayerStats(".MAIN.");
		for (int i = 0; i < globalSettings.levelsManager.fisheryDefinitions.Count; i++)
		{
			if (globalSettings.levelsManager.fisheryDefinitions[i].leaderboardName != string.Empty && globalSettings.levelsManager.fisheryDefinitions[i].leaderboardName != "TODO")
			{
				CreateLeaderboardPlayerStats(globalSettings.levelsManager.fisheryDefinitions[i].leaderboardName);
			}
		}
	}

	private void OnDestroy()
	{
	}

	public void CreateLeaderboardPlayerStats(string fisheryName)
	{
		allLeaderboardPlayerStats.Add(new LeaderboardPlayerStats(fisheryName + "_N"));
		allLeaderboardPlayerStats.Add(new LeaderboardPlayerStats(fisheryName + "_R"));
	}

	public LeaderboardPlayerStats GetCurrentLeaderboardPlayerStats(string fisheryName)
	{
		fisheryName = ((GlobalSettings.Instance.playerSettings.difficulty != PlayerSettingsMy.Difficulty.CASUAL) ? (fisheryName + "_R") : (fisheryName + "_N"));
		for (int i = 0; i < allLeaderboardPlayerStats.Count; i++)
		{
			if (allLeaderboardPlayerStats[i].fisheryName == fisheryName)
			{
				return allLeaderboardPlayerStats[i];
			}
		}
		return null;
	}

	public LeaderboardSettings GetCurrentLeaderboardSettings(LeaderboardType leaderboardType, string fisheryName)
	{
		DateTime currentDateTime = Utilities.GetCurrentDateTime();
		currentServerMonth = currentDateTime.Month;
		currentServerYear = currentDateTime.Year;
		string leaderboardName = string.Format("{0}.{1}_{2}_{3}_{4}", currentServerYear.ToString(), currentServerMonth.ToString("D2"), fisheryName, (!globalSettings.playerSettings.IsCasual()) ? "R" : "N", leaderboardType.ToString());
		LeaderboardSettings leaderboardSettings = GetLeaderboardSettings(leaderboardName);
		if (leaderboardSettings == null)
		{
			leaderboardSettings = new LeaderboardSettings(leaderboardName);
			leaderboardSettings.leaderboardType = leaderboardType;
			leaderboardSettings.fisheryName = fisheryName;
			leaderboardSettings.objectsToInform.Add(base.gameObject);
			this.leaderboardSettings.Add(leaderboardSettings);
		}
		return leaderboardSettings;
	}

	public LeaderboardSettings GetLeaderboardSettings(string leaderboardName)
	{
		for (int i = 0; i < leaderboardSettings.Count; i++)
		{
			if (leaderboardSettings[i].leaderboardName == leaderboardName)
			{
				return leaderboardSettings[i];
			}
		}
		return null;
	}

	public void FindTestLeaderboardSteam(string testLeaderboardName, CallResult<LeaderboardFindResult_t> onTestLeaderboardFindResult)
	{
		if (SteamManager.Initialized)
		{
			onTestLeaderboardFindResult = CallResult<LeaderboardFindResult_t>.Create(OnFindTestLeaderboardSteam);
			onTestLeaderboardFindResult.Set(SteamUserStats.FindLeaderboard(testLeaderboardName));
		}
	}

	private void OnFindTestLeaderboardSteam(LeaderboardFindResult_t value, bool ioFailure)
	{
		if (!GlobalSettings.Instance.IsMyProfileCracked())
		{
			Debug.LogError("STEAMWORKS OnFindTestLeaderboardSteam: " + value.m_hSteamLeaderboard.ToString() + " " + value.m_hSteamLeaderboard.m_SteamLeaderboard + " " + value.m_bLeaderboardFound + " " + ioFailure);
			SteamManager.hasProblemWithLeaderboards = value.m_bLeaderboardFound == 0;
			if (value.m_bLeaderboardFound > 0)
			{
				int[] pScoreDetails = new int[1];
				int nScore = 0;
				SteamAPICall_t steamAPICall_t = SteamUserStats.UploadLeaderboardScore(value.m_hSteamLeaderboard, ELeaderboardUploadScoreMethod.k_ELeaderboardUploadScoreMethodForceUpdate, nScore, pScoreDetails, 1);
			}
		}
	}

	public void FindAllLeaderboards()
	{
		if (!SteamManager.Initialized)
		{
			return;
		}
		for (int i = 0; i < 4; i++)
		{
			FindLeaderboard((LeaderboardType)i, ".MAIN.");
		}
		for (int j = 0; j < globalSettings.levelsManager.fisheryDefinitions.Count; j++)
		{
			LevelsManager.FisheryDefinition fisheryDefinition = globalSettings.levelsManager.fisheryDefinitions[j];
			if (fisheryDefinition.leaderboardName != string.Empty && fisheryDefinition.leaderboardName != "TODO")
			{
				for (int k = 0; k < 4; k++)
				{
					FindLeaderboard((LeaderboardType)k, fisheryDefinition.leaderboardName);
				}
			}
		}
	}

	public void FindLeaderboard(LeaderboardType leaderboardType, string fisheryName)
	{
		if (!globalSettings.playerSettings.IsSandbox())
		{
			LeaderboardSettings currentLeaderboardSettings = GetCurrentLeaderboardSettings(leaderboardType, fisheryName);
			if (currentLeaderboardSettings != null)
			{
				currentLeaderboardSettings.FindLeaderboard(true);
			}
		}
	}

	public void OnFindLeaderboard(LeaderboardSettings lbSettings)
	{
		if (lbSettings.findResult_t.m_bLeaderboardFound != 0)
		{
			LeaderboardPlayerStats currentLeaderboardPlayerStats = GetCurrentLeaderboardPlayerStats(lbSettings.fisheryName);
			if ((int)currentLeaderboardPlayerStats.leaderboardMonth != -1 && (int)currentLeaderboardPlayerStats.leaderboardMonth != (int)currentServerMonth)
			{
				Debug.LogError(string.Concat("leaderboardPlayerStats.leaderboardMonth != currentServerMonth ", currentLeaderboardPlayerStats.leaderboardMonth, " ", currentServerMonth));
				ClearPlayerStats(currentLeaderboardPlayerStats);
			}
			if ((int)currentLeaderboardPlayerStats.leaderboardScore == -1)
			{
				GetCurrentLeaderboardSettings(LeaderboardType.Score, lbSettings.fisheryName).DownloadMyScore();
			}
			else if ((bool)leaderboardGUI && leaderboardGUI.isVisible)
			{
				UploadScore(leaderboardGUI.currentLeaderboardType, leaderboardGUI.currentLeaderboardFishery);
				SteamStatsManager.Instance.StoreStats();
			}
		}
	}

	public bool DownloadScores(LeaderboardType leaderboardType, string fisheryName)
	{
		if (globalSettings.playerSettings.IsSandbox())
		{
			return false;
		}
		LeaderboardSettings currentLeaderboardSettings = GetCurrentLeaderboardSettings(leaderboardType, fisheryName);
		if (!SteamManager.Initialized || currentLeaderboardSettings == null)
		{
			return false;
		}
		currentLeaderboardSettings.DownloadScores();
		return true;
	}

	public void OnDownloadScores(LeaderboardSettings lbSettings)
	{
		Debug.Log("STEAMWORKS OnDownloadScores: " + lbSettings.scoresDownloaded_t.m_cEntryCount);
		if ((bool)leaderboardGUI && leaderboardGUI.isVisible)
		{
			leaderboardGUI.Refresh(lbSettings);
		}
	}

	public void OnDownloadMyScore(LeaderboardSettings lbSettings)
	{
		LeaderboardPlayerStats currentLeaderboardPlayerStats = GetCurrentLeaderboardPlayerStats(lbSettings.fisheryName);
		if ((int)currentLeaderboardPlayerStats.leaderboardScore == -1)
		{
			if (lbSettings.myScoresDownloaded_t.m_cEntryCount == 0)
			{
				ClearPlayerStats(currentLeaderboardPlayerStats);
				return;
			}
			int[] leaderboardMyDetails = GetCurrentLeaderboardSettings(LeaderboardType.Score, lbSettings.fisheryName).leaderboardMyDetails;
			currentLeaderboardPlayerStats.leaderboardLevel = leaderboardMyDetails[0];
			currentLeaderboardPlayerStats.leaderboardExp = leaderboardMyDetails[1];
			currentLeaderboardPlayerStats.leaderboardTotalFishCount = leaderboardMyDetails[2];
			currentLeaderboardPlayerStats.leaderboardTotalFishWeight = leaderboardMyDetails[3];
			currentLeaderboardPlayerStats.leaderboardBiggestFishSpecies = leaderboardMyDetails[4];
			currentLeaderboardPlayerStats.leaderboardBiggestFishWeight = leaderboardMyDetails[5];
			currentLeaderboardPlayerStats.leaderboardBiggestFishLength = 0;
			currentLeaderboardPlayerStats.leaderboardScore = leaderboardMyDetails[6];
			currentLeaderboardPlayerStats.leaderboardMonth = currentServerMonth;
		}
	}

	public void UploadAllScores(string fisheryName)
	{
		for (int i = 0; i < 4; i++)
		{
			UploadScore((LeaderboardType)i, fisheryName);
		}
	}

	public bool UploadScore(LeaderboardType leaderboardType, string fisheryName, int score = -1)
	{
		if (globalSettings == null)
		{
			return false;
		}
		if (globalSettings.playerSettings.IsSandbox())
		{
			return false;
		}
		LeaderboardSettings currentLeaderboardSettings = GetCurrentLeaderboardSettings(leaderboardType, fisheryName);
		LeaderboardPlayerStats currentLeaderboardPlayerStats = GetCurrentLeaderboardPlayerStats(fisheryName);
		if (currentLeaderboardPlayerStats == null)
		{
			Debug.LogError("leaderboardPlayerStats == null " + currentLeaderboardSettings.leaderboardName);
			return false;
		}
		if ((int)currentLeaderboardPlayerStats.leaderboardScore < 0 || (int)currentLeaderboardPlayerStats.leaderboardTotalFishCount < 0 || (int)currentLeaderboardPlayerStats.leaderboardTotalFishWeight < 0)
		{
			Debug.LogError("UploadScore score not loaded yet " + currentLeaderboardSettings.leaderboardName);
		}
		if (currentLeaderboardSettings.leaderboardHandle.m_SteamLeaderboard == 0)
		{
			FindLeaderboard(leaderboardType, fisheryName);
			return false;
		}
		if (GlobalSettings.Instance.IsMyProfileCracked())
		{
			return false;
		}
		int[] array = new int[7]
		{
			Mathf.Max(globalSettings.playerSettings.playersLevel, currentLeaderboardPlayerStats.leaderboardLevel),
			Mathf.Max(globalSettings.playerSettings.playersExperience, currentLeaderboardPlayerStats.leaderboardExp),
			currentLeaderboardPlayerStats.leaderboardTotalFishCount,
			currentLeaderboardPlayerStats.leaderboardTotalFishWeight,
			currentLeaderboardPlayerStats.leaderboardBiggestFishSpecies,
			currentLeaderboardPlayerStats.leaderboardBiggestFishWeight,
			currentLeaderboardPlayerStats.leaderboardScore
		};
		if (!globalSettings.playerSettings.CheckMyStatsIntegrity())
		{
			Debug.LogError("Fake leaderboard");
			score = 0;
		}
		else if (score == -1)
		{
			switch (leaderboardType)
			{
			case LeaderboardType.FishCount:
				score = array[2];
				break;
			case LeaderboardType.FishWeight:
				score = array[3];
				break;
			case LeaderboardType.BiggestWeight:
				score = array[5];
				break;
			case LeaderboardType.Score:
				score = array[6];
				break;
			}
		}
		currentLeaderboardSettings.UploadScore(score, array);
		return true;
	}

	public void OnUploadScore(LeaderboardSettings lbSettings)
	{
		Debug.Log("STEAMWORKS OnUploadScore: " + lbSettings.scoresUploaded_t.m_bScoreChanged + " " + lbSettings.scoresUploaded_t.m_nScore);
		if ((bool)leaderboardGUI && leaderboardGUI.isVisible)
		{
			DownloadScores(leaderboardGUI.currentLeaderboardType, leaderboardGUI.currentLeaderboardFishery);
		}
	}

	[Button]
	public void CreateAllLeaderboards()
	{
		for (int i = 0; i < 2; i++)
		{
			for (int j = 0; j < 4; j++)
			{
				object[] obj = new object[5]
				{
					createAllYear.ToString(),
					createAllMonth.ToString("D2"),
					createAllName,
					(i != 0) ? "R" : "N",
					null
				};
				LeaderboardType leaderboardType = (LeaderboardType)j;
				obj[4] = leaderboardType.ToString();
				string pchLeaderboardName = string.Format("{0}.{1}_{2}_{3}_{4}", obj);
				SteamAPICall_t steamAPICall_t = SteamUserStats.FindOrCreateLeaderboard(pchLeaderboardName, ELeaderboardSortMethod.k_ELeaderboardSortMethodDescending, ELeaderboardDisplayType.k_ELeaderboardDisplayTypeNumeric);
			}
		}
	}

	public void ClearPlayerStats(LeaderboardPlayerStats leaderboardPlayerStats)
	{
		leaderboardPlayerStats.leaderboardLevel = globalSettings.playerSettings.playersLevel;
		leaderboardPlayerStats.leaderboardExp = globalSettings.playerSettings.playersExperience;
		leaderboardPlayerStats.leaderboardTotalFishCount = 0;
		leaderboardPlayerStats.leaderboardTotalFishWeight = 0;
		leaderboardPlayerStats.leaderboardBiggestFishSpecies = -1;
		leaderboardPlayerStats.leaderboardBiggestFishWeight = -1;
		leaderboardPlayerStats.leaderboardBiggestFishLength = -1;
		leaderboardPlayerStats.leaderboardScore = 0;
		leaderboardPlayerStats.leaderboardMonth = currentServerMonth;
	}

	public LeaderboardSettings FindLeaderboardSettings(string leaderboardName)
	{
		for (int i = 0; i < leaderboardSettings.Count; i++)
		{
			if (leaderboardSettings[i].leaderboardName == leaderboardName)
			{
				return leaderboardSettings[i];
			}
		}
		return null;
	}
}