using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using UnityEngine;

public static class SaveManager
{
	public static Announcement LastAnnouncement
	{
		get
		{
			SaveManager.LoadAnnouncement();
			return SaveManager.lastAnnounce;
		}
		set
		{
			SaveManager.lastAnnounce = value;
			SaveManager.SaveAnnouncement();
		}
	}

	public static DateTime LastStartDate
	{
		get
		{
			SaveManager.LoadSecureData2();
			return SaveManager.lastStartDate;
		}
		set
		{
			SaveManager.LoadSecureData2();
			if (SaveManager.lastStartDate < value)
			{
				SaveManager.lastStartDate = value;
				SaveManager.SaveSecureData2();
			}
		}
	}

	public static int Month
	{
		get
		{
			return SaveManager.LastStartDate.Month;
		}
	}

	public static bool BoughtNoAds
	{
		get
		{
			SaveManager.LoadSecureData();
			return SaveManager.purchases.Contains("bought_ads");
		}
	}

	public static bool CensorChat
	{
		get
		{
			SaveManager.LoadPlayerPrefs();
			return SaveManager.censorChat;
		}
		set
		{
			SaveManager.LoadPlayerPrefs();
			SaveManager.censorChat = value;
			SaveManager.SavePlayerPrefs();
		}
	}

	public static ShowAdsState ShowAdsScreen
	{
		get
		{
			SaveManager.LoadPlayerPrefs();
			return (ShowAdsState)SaveManager.showAdsScreen;
		}
		set
		{
			SaveManager.LoadPlayerPrefs();
			SaveManager.showAdsScreen = (byte)value;
			SaveManager.SavePlayerPrefs();
		}
	}

	public static bool SendDataScreen
	{
		get
		{
			SaveManager.LoadPlayerPrefs();
			return SaveManager.sendDataScreen;
		}
		set
		{
			SaveManager.LoadPlayerPrefs();
			SaveManager.sendDataScreen = value;
			SaveManager.SavePlayerPrefs();
		}
	}

	public static bool SendName
	{
		get
		{
			SaveManager.LoadPlayerPrefs();
			return SaveManager.sendName && SaveManager.SendTelemetry;
		}
		set
		{
			SaveManager.LoadPlayerPrefs();
			SaveManager.sendName = value;
			SaveManager.SavePlayerPrefs();
		}
	}

	public static bool SendTelemetry
	{
		get
		{
			SaveManager.LoadPlayerPrefs();
			return SaveManager.sendTelemetry;
		}
		set
		{
			SaveManager.LoadPlayerPrefs();
			SaveManager.sendTelemetry = value;
			SaveManager.SavePlayerPrefs();
		}
	}

	public static bool ShowMinPlayerWarning
	{
		get
		{
			SaveManager.LoadPlayerPrefs();
			return SaveManager.showMinPlayerWarning;
		}
		set
		{
			SaveManager.LoadPlayerPrefs();
			SaveManager.showMinPlayerWarning = value;
			SaveManager.SavePlayerPrefs();
		}
	}

	public static bool ShowOnlineHelp
	{
		get
		{
			SaveManager.LoadPlayerPrefs();
			return SaveManager.showOnlineHelp;
		}
		set
		{
			SaveManager.LoadPlayerPrefs();
			SaveManager.showOnlineHelp = value;
			SaveManager.SavePlayerPrefs();
		}
	}

	public static float SfxVolume
	{
		get
		{
			SaveManager.LoadPlayerPrefs();
			return (float)SaveManager.sfxVolume / 255f;
		}
		set
		{
			SaveManager.LoadPlayerPrefs();
			SaveManager.sfxVolume = (byte)(value * 255f);
			SaveManager.SavePlayerPrefs();
		}
	}

	public static float MusicVolume
	{
		get
		{
			SaveManager.LoadPlayerPrefs();
			return (float)SaveManager.musicVolume / 255f;
		}
		set
		{
			SaveManager.LoadPlayerPrefs();
			SaveManager.musicVolume = (byte)(value * 255f);
			SaveManager.SavePlayerPrefs();
		}
	}

	public static int TouchConfig
	{
		get
		{
			SaveManager.LoadPlayerPrefs();
			return SaveManager.touchConfig;
		}
		set
		{
			SaveManager.LoadPlayerPrefs();
			SaveManager.touchConfig = value;
			SaveManager.SavePlayerPrefs();
		}
	}

	public static float JoystickSize
	{
		get
		{
			SaveManager.LoadPlayerPrefs();
			return SaveManager.joyStickSize;
		}
		set
		{
			SaveManager.LoadPlayerPrefs();
			SaveManager.joyStickSize = value;
			SaveManager.SavePlayerPrefs();
		}
	}

	public static string PlayerName
	{
		get
		{
			SaveManager.LoadPlayerPrefs();
			return SaveManager.lastPlayerName ?? "Enter Name";
		}
		set
		{
			SaveManager.LoadPlayerPrefs();
			SaveManager.lastPlayerName = value;
			SaveManager.SavePlayerPrefs();
		}
	}

	public static uint LastPet
	{
		get
		{
			SaveManager.LoadPlayerPrefs();
			return SaveManager.lastPet;
		}
		set
		{
			SaveManager.LoadPlayerPrefs();
			SaveManager.lastPet = value;
			SaveManager.SavePlayerPrefs();
		}
	}

	public static uint LastHat
	{
		get
		{
			SaveManager.LoadPlayerPrefs();
			return SaveManager.lastHat;
		}
		set
		{
			SaveManager.LoadPlayerPrefs();
			SaveManager.lastHat = value;
			SaveManager.SavePlayerPrefs();
		}
	}

	public static uint LastSkin
	{
		get
		{
			SaveManager.LoadPlayerPrefs();
			return SaveManager.lastSkin;
		}
		set
		{
			SaveManager.LoadPlayerPrefs();
			SaveManager.lastSkin = value;
			SaveManager.SavePlayerPrefs();
		}
	}

	public static uint LastLanguage
	{
		get
		{
			SaveManager.LoadPlayerPrefs();
			return SaveManager.lastLanguage;
		}
		set
		{
			SaveManager.LoadPlayerPrefs();
			SaveManager.lastLanguage = value;
			SaveManager.SavePlayerPrefs();
		}
	}

	public static byte BodyColor
	{
		get
		{
			SaveManager.LoadPlayerPrefs();
			return (byte)(SaveManager.colorConfig & 255U);
		}
		set
		{
			SaveManager.LoadPlayerPrefs();
			SaveManager.colorConfig = ((SaveManager.colorConfig & 16776960U) | (uint)(value & byte.MaxValue));
			SaveManager.SavePlayerPrefs();
		}
	}

	public static GameOptionsData GameHostOptions
	{
		get
		{
			if (SaveManager.hostOptionsData == null)
			{
				SaveManager.hostOptionsData = SaveManager.LoadGameOptions("gameHostOptions");
			}
			SaveManager.hostOptionsData.NumImpostors = Mathf.Clamp(SaveManager.hostOptionsData.NumImpostors, 1, 3);
			SaveManager.hostOptionsData.KillDistance = Mathf.Clamp(SaveManager.hostOptionsData.KillDistance, 0, 2);
			return SaveManager.hostOptionsData;
		}
		set
		{
			SaveManager.hostOptionsData = value;
			SaveManager.SaveGameOptions(SaveManager.hostOptionsData, "gameHostOptions");
		}
	}

	public static GameOptionsData GameSearchOptions
	{
		get
		{
			GameOptionsData result;
			if ((result = SaveManager.searchOptionsData) == null)
			{
				result = (SaveManager.searchOptionsData = SaveManager.LoadGameOptions("gameSearchOptions"));
			}
			return result;
		}
		set
		{
			SaveManager.searchOptionsData = value;
			SaveManager.SaveGameOptions(SaveManager.searchOptionsData, "gameSearchOptions");
		}
	}

	private static bool loaded;

	private static bool loadedStats;

	private static bool loadedAnnounce;

	private static string lastPlayerName;

	private static byte sfxVolume = byte.MaxValue;

	private static byte musicVolume = byte.MaxValue;

	private static bool showMinPlayerWarning = true;

	private static bool showOnlineHelp = true;

	private static bool sendDataScreen = false;

	private static byte showAdsScreen = 0;

	private static bool sendName = true;

	private static bool sendTelemetry = true;

	private static bool censorChat = true;

	private static int touchConfig;

	private static float joyStickSize = 1f;

	private static uint colorConfig;

	private static uint lastPet;

	private static uint lastHat;

	private static uint lastSkin;

	private static uint lastLanguage;

	private static GameOptionsData hostOptionsData;

	private static GameOptionsData searchOptionsData;

	private static Announcement lastAnnounce;

	private static SaveManager.SecureDataFile secure2 = new SaveManager.SecureDataFile(Path.Combine(Application.persistentDataPath, "secure2"));

	private static DateTime lastStartDate = DateTime.MinValue;

	private static SaveManager.SecureDataFile purchaseFile = new SaveManager.SecureDataFile(Path.Combine(Application.persistentDataPath, "secureNew"));

	private static HashSet<string> purchases = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

	private class SecureDataFile
	{
		public bool Loaded { get; private set; }

		private string filePath;

		public SecureDataFile(string filePath)
		{
			this.filePath = filePath;
		}

		public BinaryReader LoadData()
		{
			this.Loaded = true;
			Debug.Log("Loading secure: " + this.filePath);
			if (File.Exists(this.filePath))
			{
				byte[] array = File.ReadAllBytes(this.filePath);
				for (int i = 0; i < array.Length; i++)
				{
					byte[] array2 = array;
					int num = i;
					array2[num] ^= (byte)(i % 212);
				}
				try
				{
					BinaryReader binaryReader = new BinaryReader(new MemoryStream(array));
					binaryReader.ReadString();
					return binaryReader;
				}
				catch
				{
					Debug.Log("Deleted corrupt secure file inner");
					this.Delete();
				}
			}
			return null;
		}

		public void SaveData(params object[] items)
		{
			byte[] array;
			using (MemoryStream memoryStream = new MemoryStream())
			{
				using (BinaryWriter binaryWriter = new BinaryWriter(memoryStream))
				{
					binaryWriter.Write(SystemInfo.deviceUniqueIdentifier);
					foreach (object obj in items)
					{
						if (obj is long)
						{
							binaryWriter.Write((long)obj);
						}
						else if (obj is HashSet<string>)
						{
							foreach (string value in ((HashSet<string>)obj))
							{
								binaryWriter.Write(value);
							}
						}
					}
					binaryWriter.Flush();
					memoryStream.Position = 0L;
					array = memoryStream.ToArray();
				}
			}
			for (int j = 0; j < array.Length; j++)
			{
				byte[] array2 = array;
				int num = j;
				array2[num] ^= (byte)(j % 212);
			}
			File.WriteAllBytes(this.filePath, array);
		}

		public void Delete()
		{
			try
			{
				File.Delete(this.filePath);
			}
			catch
			{
			}
		}
	}

	private static void SaveSecureData2()
	{
		SaveManager.secure2.SaveData(new object[]
		{
			SaveManager.lastStartDate.Ticks
		});
	}

	private static void LoadSecureData2()
	{
		if (SaveManager.secure2.Loaded)
		{
			return;
		}
		try
		{
			using (BinaryReader binaryReader = SaveManager.secure2.LoadData())
			{
				SaveManager.lastStartDate = new DateTime(binaryReader.ReadInt64());
			}
		}
		catch
		{
		}
	}

	public static bool GetPurchase(string key)
	{
		SaveManager.LoadSecureData();
		return SaveManager.purchases.Contains(key);
	}

	public static void SetPurchased(string key)
	{
		SaveManager.LoadSecureData();
		SaveManager.purchases.Add(key ?? "null");
		if (key == "bought_ads")
		{
			SaveManager.ShowAdsScreen = ShowAdsState.Purchased;
		}
		SaveManager.SaveSecureData();
	}

	private static void LoadSecureData()
	{
		if (SaveManager.purchaseFile.Loaded)
		{
			return;
		}
		try
		{
			using (BinaryReader binaryReader = SaveManager.purchaseFile.LoadData())
			{
				while (binaryReader.BaseStream.Position < binaryReader.BaseStream.Length)
				{
					SaveManager.purchases.Add(binaryReader.ReadString());
				}
			}
		}
		catch (NullReferenceException)
		{
		}
		catch (Exception arg)
		{
			Debug.Log("Deleted corrupt secure file outer: " + arg);
			SaveManager.purchaseFile.Delete();
		}
	}

	private static void SaveSecureData()
	{
		SaveManager.purchaseFile.SaveData(new object[]
		{
			SaveManager.purchases
		});
	}

	private static GameOptionsData LoadGameOptions(string filename)
	{
		string path = Path.Combine(Application.persistentDataPath, filename);
		if (File.Exists(path))
		{
			using (FileStream fileStream = File.OpenRead(path))
			{
				using (BinaryReader binaryReader = new BinaryReader(fileStream))
				{
					return GameOptionsData.Deserialize(binaryReader) ?? new GameOptionsData();
				}
			}
		}
		return new GameOptionsData();
	}

	private static void SaveGameOptions(GameOptionsData data, string filename)
	{
		using (FileStream fileStream = new FileStream(Path.Combine(Application.persistentDataPath, filename), FileMode.Create, FileAccess.Write))
		{
			using (BinaryWriter binaryWriter = new BinaryWriter(fileStream))
			{
				data.Serialize(binaryWriter);
			}
		}
	}

	private static void LoadAnnouncement()
	{
		if (SaveManager.loadedAnnounce)
		{
			return;
		}
		SaveManager.loadedAnnounce = true;
		string path = Path.Combine(Application.persistentDataPath, "announcement");
		if (File.Exists(path))
		{
			string[] array = File.ReadAllText(path).Split(new char[1]);
			if (array.Length == 3)
			{
				Announcement announcement = default(Announcement);
				SaveManager.TryGetUint(array, 0, out announcement.Id);
				announcement.AnnounceText = array[1];
				SaveManager.TryGetInt(array, 2, out announcement.DateFetched);
				SaveManager.lastAnnounce = announcement;
				return;
			}
			SaveManager.lastAnnounce = default(Announcement);
		}
	}

	public static void SaveAnnouncement()
	{
		File.WriteAllText(Path.Combine(Application.persistentDataPath, "announcement"), string.Join("\0", new object[]
		{
			SaveManager.lastAnnounce.Id,
			SaveManager.lastAnnounce.AnnounceText,
			SaveManager.lastAnnounce.DateFetched
		}));
	}

	private static void LoadPlayerPrefs()
	{
		if (SaveManager.loaded)
		{
			return;
		}
		SaveManager.loaded = true;
		string path = Path.Combine(Application.persistentDataPath, "playerPrefs");
		if (File.Exists(path))
		{
			string[] array = File.ReadAllText(path).Split(new char[]
			{
				','
			});
			SaveManager.lastPlayerName = array[0];
			if (array.Length > 1)
			{
				int.TryParse(array[1], out SaveManager.touchConfig);
			}
			if (array.Length <= 2 || !uint.TryParse(array[2], out SaveManager.colorConfig))
			{
				SaveManager.colorConfig = (uint)((byte)(Palette.PlayerColors.RandomIdx<Color32>() << 16) | (byte)(Palette.PlayerColors.RandomIdx<Color32>() << 8) | (byte)Palette.PlayerColors.RandomIdx<Color32>());
			}
			SaveManager.TryGetBool(array, 4, out SaveManager.sendName, false);
			SaveManager.TryGetBool(array, 5, out SaveManager.sendTelemetry, false);
			SaveManager.TryGetBool(array, 6, out SaveManager.sendDataScreen, false);
			SaveManager.TryGetByte(array, 7, out SaveManager.showAdsScreen);
			SaveManager.TryGetBool(array, 8, out SaveManager.showMinPlayerWarning, false);
			SaveManager.TryGetBool(array, 9, out SaveManager.showOnlineHelp, false);
			SaveManager.TryGetUint(array, 10, out SaveManager.lastHat);
			SaveManager.TryGetByte(array, 11, out SaveManager.sfxVolume);
			SaveManager.TryGetByte(array, 12, out SaveManager.musicVolume);
			SaveManager.TryGetFloat(array, 13, out SaveManager.joyStickSize, 1f);
			SaveManager.TryGetUint(array, 15, out SaveManager.lastSkin);
			SaveManager.TryGetUint(array, 16, out SaveManager.lastPet);
			SaveManager.TryGetBool(array, 17, out SaveManager.censorChat, true);
			SaveManager.TryGetUint(array, 18, out SaveManager.lastLanguage);
		}
	}

	private static void SavePlayerPrefs()
	{
		SaveManager.LoadPlayerPrefs();
		File.WriteAllText(Path.Combine(Application.persistentDataPath, "playerPrefs"), string.Join(",", new object[]
		{
			SaveManager.lastPlayerName,
			SaveManager.touchConfig,
			SaveManager.colorConfig,
			1,
			SaveManager.sendName,
			SaveManager.sendTelemetry,
			SaveManager.sendDataScreen,
			SaveManager.showAdsScreen,
			SaveManager.showMinPlayerWarning,
			SaveManager.showOnlineHelp,
			SaveManager.lastHat,
			SaveManager.sfxVolume,
			SaveManager.musicVolume,
			SaveManager.joyStickSize.ToString(CultureInfo.InvariantCulture),
			0L,
			SaveManager.lastSkin,
			SaveManager.lastPet,
			SaveManager.censorChat,
			SaveManager.lastLanguage
		}));
	}

	private static void TryGetBool(string[] parts, int index, out bool value, bool @default = false)
	{
		value = @default;
		if (parts.Length > index)
		{
			bool.TryParse(parts[index], out value);
		}
	}

	private static void TryGetByte(string[] parts, int index, out byte value)
	{
		value = 0;
		if (parts.Length > index)
		{
			byte.TryParse(parts[index], out value);
		}
	}

	private static void TryGetFloat(string[] parts, int index, out float value, float @default = 0f)
	{
		value = @default;
		if (parts.Length > index)
		{
			float.TryParse(parts[index], NumberStyles.Number, CultureInfo.InvariantCulture, out value);
		}
	}

	private static void TryGetInt(string[] parts, int index, out int value)
	{
		value = 0;
		if (parts.Length > index)
		{
			int.TryParse(parts[index], out value);
		}
	}

	private static void TryGetUint(string[] parts, int index, out uint value)
	{
		value = 0U;
		if (parts.Length > index)
		{
			uint.TryParse(parts[index], out value);
		}
	}

	private static void TryGetDateTicks(string[] parts, int index, out DateTime value)
	{
		value = DateTime.MinValue;
		long ticks;
		if (parts.Length > index && long.TryParse(parts[index], out ticks))
		{
			value = new DateTime(ticks, DateTimeKind.Utc);
		}
	}
}