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

public class LevelsManager : MonoBehaviour
{
	[Serializable]
	public class FisheryDefinition
	{
		public string unitySceneName = "TODO";

		public int orderId;

		public int fisheryId;

		public bool iceLevel;

		public ObscuredBool isUnlocked = false;

		public ObscuredBool isAvailable = true;

		public ObscuredBool isAvailableFromDLCs = true;

		public ObscuredBool onlyInBeta = false;

		public ObscuredBool onlyCheat = false;

		public List<DLCManager.DLC_ID> fromDLC = new List<DLCManager.DLC_ID>();

		public ObscuredInt availableEntries = 0;

		public ObscuredInt entryPriceSmall = 100;

		public int requiredLevel = 1;

		public string name = "TODO";

		public string description = "TODO";

		public string location = "TODO";

		public string leaderboardName = "TODO";

		public Sprite thumbnail;

		public Sprite loadingBackground;

		public Texture loadingBackgroundVR;

		public float[] temperatureNormal = new float[3];

		public List<Fish.Species> fishSpecies = new List<Fish.Species>();

		public FisheryStats fisheryStats = new FisheryStats();
	}

	[Serializable]
	public class FisheryStats
	{
		public ObscuredFloat timeSpent = 0f;

		public ObscuredInt bitesAmount = 0;

		public ObscuredInt score = 0;

		public ObscuredInt fishCaught = 0;

		public ObscuredFloat weightSum = 0f;

		public Fish.Species biggestFish = Fish.Species.AMBERJACK;

		public ObscuredFloat biggestWeight = 0f;

		public ObscuredFloat biggestLength = 0f;
	}

	public bool unlockAll = true;

	public bool sortFisheries = true;

	public List<FisheryDefinition> missions = new List<FisheryDefinition>();

	public List<FisheryDefinition> fisheryDefinitions = new List<FisheryDefinition>();

	public int currentFishery;

	public bool isTournament;

	public bool createTournament;

	public bool isMultiplayer;

	public bool multiAnyLanguage;

	public bool multiPrivateRoom;

	public string multiRoomName = string.Empty;

	public string multiRoomNameLast = string.Empty;

	public string multiRoomNameArcade = string.Empty;

	private PlayerSettingsMy playerSettings;

	private void Awake()
	{
		if (sortFisheries)
		{
			fisheryDefinitions.Sort((FisheryDefinition i1, FisheryDefinition i2) => i1.orderId.CompareTo(i2.orderId));
		}
	}

	private void Start()
	{
		playerSettings = GlobalSettings.Instance.playerSettings;
		fisheryDefinitions[0].isUnlocked = true;
	}

	private void Update()
	{
	}

	public FisheryDefinition GetFishery(int fisheryNumber)
	{
		if (fisheryDefinitions.Count <= fisheryNumber)
		{
			Debug.LogError("Level not found: " + fisheryNumber);
			return null;
		}
		return fisheryDefinitions[fisheryNumber];
	}

	public FisheryDefinition GetFisheryById(int id)
	{
		for (int i = 0; i < fisheryDefinitions.Count; i++)
		{
			if (fisheryDefinitions[i].fisheryId == id)
			{
				return fisheryDefinitions[i];
			}
		}
		return null;
	}

	public FisheryDefinition GetFisheryByName(string fisheryName)
	{
		for (int i = 0; i < fisheryDefinitions.Count; i++)
		{
			if (fisheryDefinitions[i].unitySceneName == fisheryName)
			{
				return fisheryDefinitions[i];
			}
		}
		return null;
	}

	public FisheryDefinition GetFisheryByLeaderboardName(string fisheryName)
	{
		for (int i = 0; i < fisheryDefinitions.Count; i++)
		{
			if (fisheryDefinitions[i].leaderboardName == fisheryName)
			{
				return fisheryDefinitions[i];
			}
		}
		return null;
	}

	public FisheryDefinition GetCurrentFishery()
	{
		return GetFishery(currentFishery);
	}

	public int GetFisheryMissionNumber(FisheryDefinition fisheryDefinition)
	{
		for (int i = 0; i < fisheryDefinitions.Count; i++)
		{
			if (fisheryDefinitions[i].fisheryId == fisheryDefinition.fisheryId)
			{
				return i;
			}
		}
		return -1;
	}

	public void PlayerCaughtFish(Fish fish)
	{
		FisheryDefinition fisheryDefinition = GetCurrentFishery();
		FisheryStats fisheryStats = fisheryDefinition.fisheryStats;
		fisheryStats.score = (int)fisheryStats.score + fish.GetExpPrize();
		++fisheryDefinition.fisheryStats.fishCaught;
		FisheryStats fisheryStats2 = fisheryDefinition.fisheryStats;
		fisheryStats2.weightSum = (float)fisheryStats2.weightSum + fish.Weight;
		if (fish.Weight > (float)fisheryDefinition.fisheryStats.biggestWeight)
		{
			fisheryDefinition.fisheryStats.biggestFish = fish.species;
			fisheryDefinition.fisheryStats.biggestWeight = fish.Weight;
			fisheryDefinition.fisheryStats.biggestLength = fish.Length;
		}
		for (int i = 0; i < 2; i++)
		{
			LeaderboardsManager.LeaderboardPlayerStats currentLeaderboardPlayerStats = LeaderboardsManager.Instance.GetCurrentLeaderboardPlayerStats((i != 0) ? GetCurrentFishery().leaderboardName : ".MAIN.");
			if (currentLeaderboardPlayerStats != null && (int)currentLeaderboardPlayerStats.leaderboardScore != -1)
			{
				int num = Mathf.RoundToInt(fish.Weight * 1000f);
				++currentLeaderboardPlayerStats.leaderboardTotalFishCount;
				currentLeaderboardPlayerStats.leaderboardTotalFishWeight = (int)currentLeaderboardPlayerStats.leaderboardTotalFishWeight + num;
				if (num > (int)currentLeaderboardPlayerStats.leaderboardBiggestFishWeight)
				{
					currentLeaderboardPlayerStats.leaderboardBiggestFishSpecies = (int)fish.species;
					currentLeaderboardPlayerStats.leaderboardBiggestFishWeight = num;
					currentLeaderboardPlayerStats.leaderboardBiggestFishLength = Mathf.RoundToInt(fish.Length * 1000f);
				}
			}
		}
		Save();
	}

	public void Save()
	{
		string currentProfilePrefix = GlobalSettings.Instance.saveManager.GetCurrentProfilePrefix();
		using (ES2Writer eS2Writer = ES2Writer.Create(currentProfilePrefix))
		{
			for (int i = 0; i < fisheryDefinitions.Count; i++)
			{
				eS2Writer.Write((int)fisheryDefinitions[i].availableEntries, fisheryDefinitions[i].name + "_availableEntries");
				eS2Writer.Write((float)fisheryDefinitions[i].fisheryStats.timeSpent, fisheryDefinitions[i].name + "_Stats_timeSpent");
				eS2Writer.Write((int)fisheryDefinitions[i].fisheryStats.bitesAmount, fisheryDefinitions[i].name + "_Stats_bitesAmount");
				eS2Writer.Write((int)fisheryDefinitions[i].fisheryStats.score, fisheryDefinitions[i].name + "_Stats_score");
				eS2Writer.Write((int)fisheryDefinitions[i].fisheryStats.fishCaught, fisheryDefinitions[i].name + "_Stats_fishCaught");
				eS2Writer.Write((float)fisheryDefinitions[i].fisheryStats.weightSum, fisheryDefinitions[i].name + "_Stats_weightSum");
				eS2Writer.Write((int)fisheryDefinitions[i].fisheryStats.biggestFish, fisheryDefinitions[i].name + "_Stats_biggestFish");
				eS2Writer.Write((float)fisheryDefinitions[i].fisheryStats.biggestWeight, fisheryDefinitions[i].name + "_Stats_biggestWeight");
				eS2Writer.Write((float)fisheryDefinitions[i].fisheryStats.biggestLength, fisheryDefinitions[i].name + "_Stats_biggestLength");
			}
			eS2Writer.Write(isMultiplayer, "isMultiplayer");
			eS2Writer.Write(multiAnyLanguage, "multiAnyLanguage");
			try
			{
				eS2Writer.Save();
			}
			catch (Exception exception)
			{
				Debug.LogException(exception, this);
			}
			Debug.Log("Save LevelsManager");
		}
		fisheryDefinitions[0].availableEntries = -1;
	}

	public void Load()
	{
		string currentProfilePrefix = GlobalSettings.Instance.saveManager.GetCurrentProfilePrefix();
		using (ES2Reader reader = ES2Reader.Create(currentProfilePrefix))
		{
			for (int i = 0; i < fisheryDefinitions.Count; i++)
			{
				fisheryDefinitions[i].availableEntries = SaveManager.Read(reader, fisheryDefinitions[i].name + "_availableEntries", 0);
				fisheryDefinitions[i].fisheryStats.timeSpent = SaveManager.Read(reader, fisheryDefinitions[i].name + "_Stats_timeSpent", 0f);
				fisheryDefinitions[i].fisheryStats.bitesAmount = SaveManager.Read(reader, fisheryDefinitions[i].name + "_Stats_bitesAmount", 0);
				fisheryDefinitions[i].fisheryStats.score = SaveManager.Read(reader, fisheryDefinitions[i].name + "_Stats_score", 0);
				fisheryDefinitions[i].fisheryStats.fishCaught = SaveManager.Read(reader, fisheryDefinitions[i].name + "_Stats_fishCaught", 0);
				fisheryDefinitions[i].fisheryStats.weightSum = SaveManager.Read(reader, fisheryDefinitions[i].name + "_Stats_weightSum", 0f);
				fisheryDefinitions[i].fisheryStats.biggestFish = (Fish.Species)SaveManager.Read(reader, fisheryDefinitions[i].name + "_Stats_biggestFish", 0);
				fisheryDefinitions[i].fisheryStats.biggestWeight = SaveManager.Read(reader, fisheryDefinitions[i].name + "_Stats_biggestWeight", 0f);
				fisheryDefinitions[i].fisheryStats.biggestLength = SaveManager.Read(reader, fisheryDefinitions[i].name + "_Stats_biggestLength", 0f);
			}
			isMultiplayer = SaveManager.Read(reader, "isMultiplayer", true);
			if (GlobalSettings.Instance.currentPlatform == GlobalSettings.Platform.ARCADE)
			{
				isMultiplayer = false;
			}
			multiAnyLanguage = SaveManager.Read(reader, "multiAnyLanguage", true);
		}
		fisheryDefinitions[0].availableEntries = -1;
		if (unlockAll)
		{
			UnlockAll();
		}
		UpdateDLCSettings();
	}

	public void Reset()
	{
		if (GlobalSettings.Instance.currentPlatform != GlobalSettings.Platform.ARCADE)
		{
			for (int i = 0; i < fisheryDefinitions.Count; i++)
			{
				fisheryDefinitions[i].isUnlocked = false;
				fisheryDefinitions[i].availableEntries = 0;
				fisheryDefinitions[i].fisheryStats.timeSpent = 0f;
				fisheryDefinitions[i].fisheryStats.bitesAmount = 0;
				fisheryDefinitions[i].fisheryStats.score = 0;
				fisheryDefinitions[i].fisheryStats.fishCaught = 0;
				fisheryDefinitions[i].fisheryStats.weightSum = 0f;
				fisheryDefinitions[i].fisheryStats.biggestFish = Fish.Species.AMBERJACK;
				fisheryDefinitions[i].fisheryStats.biggestWeight = 0f;
				fisheryDefinitions[i].fisheryStats.biggestLength = 0f;
			}
			fisheryDefinitions[0].isUnlocked = true;
			fisheryDefinitions[0].availableEntries = -1;
			if (unlockAll)
			{
				UnlockAll();
			}
			isMultiplayer = GlobalSettings.Instance.currentPlatform != GlobalSettings.Platform.ARCADE;
			multiAnyLanguage = true;
			multiPrivateRoom = false;
			Save();
		}
	}

	public void UnlockNext()
	{
		if (currentFishery < fisheryDefinitions.Count - 1 && !fisheryDefinitions[currentFishery + 1].isUnlocked)
		{
			fisheryDefinitions[currentFishery + 1].isUnlocked = true;
		}
	}

	public void UnlockAll()
	{
		for (int i = 0; i < fisheryDefinitions.Count; i++)
		{
			fisheryDefinitions[i].isUnlocked = true;
		}
		Save();
	}

	public bool IsLevelAvailable(int levelId)
	{
		return (bool)fisheryDefinitions[levelId].isAvailable && (int)fisheryDefinitions[levelId].availableEntries != 0;
	}

	public bool CheckMissionRequirements(int fisheryNumber)
	{
		bool result = true;
		FisheryDefinition fisheryDefinition = fisheryDefinitions[fisheryNumber];
		if ((int)GlobalSettings.Instance.playerSettings.playersLevel < fisheryDefinition.requiredLevel)
		{
			result = false;
		}
		return result;
	}

	public void AddLicences(int missionNumber, int count)
	{
		FisheryDefinition fisheryDefinition = fisheryDefinitions[missionNumber];
		fisheryDefinition.availableEntries = (int)fisheryDefinition.availableEntries + count;
		Save();
	}

	public void AddAllLicences(int amount)
	{
		for (int i = 0; i < fisheryDefinitions.Count; i++)
		{
			if ((int)fisheryDefinitions[i].availableEntries >= 0)
			{
				fisheryDefinitions[i].availableEntries = amount;
			}
		}
		Save();
	}

	[Button]
	public void UpdateDLCSettings()
	{
		for (int i = 0; i < fisheryDefinitions.Count; i++)
		{
			if (fisheryDefinitions[i].fromDLC.Count > 0)
			{
				fisheryDefinitions[i].isAvailableFromDLCs = DLCManager.Instance.IsAnyDLCInstalled(fisheryDefinitions[i].fromDLC);
			}
			else
			{
				fisheryDefinitions[i].isAvailableFromDLCs = (bool)fisheryDefinitions[i].isAvailable || GlobalSettings.Instance.turnOnMyCheats;
			}
		}
	}

	public FisheryStats GetGlobalFisheryStats()
	{
		FisheryStats fisheryStats = new FisheryStats();
		for (int i = 0; i < fisheryDefinitions.Count; i++)
		{
			fisheryStats.timeSpent = (float)fisheryStats.timeSpent + (float)fisheryDefinitions[i].fisheryStats.timeSpent;
			fisheryStats.fishCaught = (int)fisheryStats.fishCaught + (int)fisheryDefinitions[i].fisheryStats.fishCaught;
			fisheryStats.weightSum = (float)fisheryStats.weightSum + (float)fisheryDefinitions[i].fisheryStats.weightSum;
			fisheryStats.bitesAmount = (int)fisheryStats.bitesAmount + (int)fisheryDefinitions[i].fisheryStats.bitesAmount;
		}
		return fisheryStats;
	}
}