using System;
using System.Collections;
using System.Collections.Generic;
using Rewired.Utils.Libraries.TinyJson;
using UnityEngine;

namespace Rewired.Data
{
	public class UserDataStore_PlayerPrefs : UserDataStore
	{
		private class SavedControllerMapData
		{
			public string xml;

			public List<int> knownActionIds;

			public SavedControllerMapData(string xml, List<int> knownActionIds)
			{
				this.xml = xml;
				this.knownActionIds = knownActionIds;
			}

			public static List<string> GetXmlStringList(List<SavedControllerMapData> data)
			{
				List<string> list = new List<string>();
				if (data == null)
				{
					return list;
				}
				for (int i = 0; i < data.Count; i++)
				{
					if (data[i] != null && !string.IsNullOrEmpty(data[i].xml))
					{
						list.Add(data[i].xml);
					}
				}
				return list;
			}
		}

		private class ControllerAssignmentSaveInfo
		{
			public class PlayerInfo
			{
				public int id;

				public bool hasKeyboard;

				public bool hasMouse;

				public JoystickInfo[] joysticks;

				public int joystickCount
				{
					get
					{
						return (joysticks != null) ? joysticks.Length : 0;
					}
				}

				public int IndexOfJoystick(int joystickId)
				{
					for (int i = 0; i < joystickCount; i++)
					{
						if (joysticks[i] != null && joysticks[i].id == joystickId)
						{
							return i;
						}
					}
					return -1;
				}

				public bool ContainsJoystick(int joystickId)
				{
					return IndexOfJoystick(joystickId) >= 0;
				}
			}

			public class JoystickInfo
			{
				public Guid instanceGuid;

				public string hardwareIdentifier;

				public int id;
			}

			public PlayerInfo[] players;

			public int playerCount
			{
				get
				{
					return (players != null) ? players.Length : 0;
				}
			}

			public ControllerAssignmentSaveInfo()
			{
			}

			public ControllerAssignmentSaveInfo(int playerCount)
			{
				players = new PlayerInfo[playerCount];
				for (int i = 0; i < playerCount; i++)
				{
					players[i] = new PlayerInfo();
				}
			}

			public int IndexOfPlayer(int playerId)
			{
				for (int i = 0; i < playerCount; i++)
				{
					if (players[i] != null && players[i].id == playerId)
					{
						return i;
					}
				}
				return -1;
			}

			public bool ContainsPlayer(int playerId)
			{
				return IndexOfPlayer(playerId) >= 0;
			}
		}

		private class JoystickAssignmentHistoryInfo
		{
			public readonly Joystick joystick;

			public readonly int oldJoystickId;

			public JoystickAssignmentHistoryInfo(Joystick joystick, int oldJoystickId)
			{
				if (joystick == null)
				{
					throw new ArgumentNullException("joystick");
				}
				this.joystick = joystick;
				this.oldJoystickId = oldJoystickId;
			}
		}

		private const string thisScriptName = "UserDataStore_PlayerPrefs";

		private const string editorLoadedMessage = "\nIf unexpected input issues occur, the loaded XML data may be outdated or invalid. Clear PlayerPrefs using the inspector option on the UserDataStore_PlayerPrefs component.";

		private const string playerPrefsKeySuffix_controllerAssignments = "ControllerAssignments";

		[SerializeField]
		[Tooltip("Should this script be used? If disabled, nothing will be saved or loaded.")]
		private bool isEnabled = true;

		[Tooltip("Should saved data be loaded on start?")]
		[SerializeField]
		private bool loadDataOnStart = true;

		[SerializeField]
		[Tooltip("Should Player Joystick assignments be saved and loaded? This is not totally reliable for all Joysticks on all platforms. Some platforms/input sources do not provide enough information to reliably save assignments from session to session and reboot to reboot.")]
		private bool loadJoystickAssignments = true;

		[SerializeField]
		[Tooltip("Should Player Keyboard assignments be saved and loaded?")]
		private bool loadKeyboardAssignments = true;

		[SerializeField]
		[Tooltip("Should Player Mouse assignments be saved and loaded?")]
		private bool loadMouseAssignments = true;

		[Tooltip("The PlayerPrefs key prefix. Change this to change how keys are stored in PlayerPrefs. Changing this will make saved data already stored with the old key no longer accessible.")]
		[SerializeField]
		private string playerPrefsKeyPrefix = "RewiredSaveData";

		private bool allowImpreciseJoystickAssignmentMatching = true;

		private bool deferredJoystickAssignmentLoadPending;

		private bool wasJoystickEverDetected;

		public bool IsEnabled
		{
			get
			{
				return isEnabled;
			}
			set
			{
				isEnabled = value;
			}
		}

		public bool LoadDataOnStart
		{
			get
			{
				return loadDataOnStart;
			}
			set
			{
				loadDataOnStart = value;
			}
		}

		public bool LoadJoystickAssignments
		{
			get
			{
				return loadJoystickAssignments;
			}
			set
			{
				loadJoystickAssignments = value;
			}
		}

		public bool LoadKeyboardAssignments
		{
			get
			{
				return loadKeyboardAssignments;
			}
			set
			{
				loadKeyboardAssignments = value;
			}
		}

		public bool LoadMouseAssignments
		{
			get
			{
				return loadMouseAssignments;
			}
			set
			{
				loadMouseAssignments = value;
			}
		}

		public string PlayerPrefsKeyPrefix
		{
			get
			{
				return playerPrefsKeyPrefix;
			}
			set
			{
				playerPrefsKeyPrefix = value;
			}
		}

		private string playerPrefsKey_controllerAssignments
		{
			get
			{
				return string.Format("{0}_{1}", playerPrefsKeyPrefix, "ControllerAssignments");
			}
		}

		private bool loadControllerAssignments
		{
			get
			{
				return loadKeyboardAssignments || loadMouseAssignments || loadJoystickAssignments;
			}
		}

		public override void Save()
		{
			if (!isEnabled)
			{
				Debug.LogWarning("Rewired: UserDataStore_PlayerPrefs is disabled and will not save any data.", this);
			}
			else
			{
				SaveAll();
			}
		}

		public override void SaveControllerData(int playerId, ControllerType controllerType, int controllerId)
		{
			if (!isEnabled)
			{
				Debug.LogWarning("Rewired: UserDataStore_PlayerPrefs is disabled and will not save any data.", this);
			}
			else
			{
				SaveControllerDataNow(playerId, controllerType, controllerId);
			}
		}

		public override void SaveControllerData(ControllerType controllerType, int controllerId)
		{
			if (!isEnabled)
			{
				Debug.LogWarning("Rewired: UserDataStore_PlayerPrefs is disabled and will not save any data.", this);
			}
			else
			{
				SaveControllerDataNow(controllerType, controllerId);
			}
		}

		public override void SavePlayerData(int playerId)
		{
			if (!isEnabled)
			{
				Debug.LogWarning("Rewired: UserDataStore_PlayerPrefs is disabled and will not save any data.", this);
			}
			else
			{
				SavePlayerDataNow(playerId);
			}
		}

		public override void SaveInputBehavior(int playerId, int behaviorId)
		{
			if (!isEnabled)
			{
				Debug.LogWarning("Rewired: UserDataStore_PlayerPrefs is disabled and will not save any data.", this);
			}
			else
			{
				SaveInputBehaviorNow(playerId, behaviorId);
			}
		}

		public override void Load()
		{
			if (!isEnabled)
			{
				Debug.LogWarning("Rewired: UserDataStore_PlayerPrefs is disabled and will not load any data.", this);
			}
			else
			{
				int num = LoadAll();
			}
		}

		public override void LoadControllerData(int playerId, ControllerType controllerType, int controllerId)
		{
			if (!isEnabled)
			{
				Debug.LogWarning("Rewired: UserDataStore_PlayerPrefs is disabled and will not load any data.", this);
			}
			else
			{
				int num = LoadControllerDataNow(playerId, controllerType, controllerId);
			}
		}

		public override void LoadControllerData(ControllerType controllerType, int controllerId)
		{
			if (!isEnabled)
			{
				Debug.LogWarning("Rewired: UserDataStore_PlayerPrefs is disabled and will not load any data.", this);
			}
			else
			{
				int num = LoadControllerDataNow(controllerType, controllerId);
			}
		}

		public override void LoadPlayerData(int playerId)
		{
			if (!isEnabled)
			{
				Debug.LogWarning("Rewired: UserDataStore_PlayerPrefs is disabled and will not load any data.", this);
			}
			else
			{
				int num = LoadPlayerDataNow(playerId);
			}
		}

		public override void LoadInputBehavior(int playerId, int behaviorId)
		{
			if (!isEnabled)
			{
				Debug.LogWarning("Rewired: UserDataStore_PlayerPrefs is disabled and will not load any data.", this);
			}
			else
			{
				int num = LoadInputBehaviorNow(playerId, behaviorId);
			}
		}

		protected override void OnInitialize()
		{
			if (loadDataOnStart)
			{
				Load();
				if (loadControllerAssignments && ReInput.controllers.joystickCount > 0)
				{
					SaveControllerAssignments();
				}
			}
		}

		protected override void OnControllerConnected(ControllerStatusChangedEventArgs args)
		{
			if (isEnabled && args.controllerType == ControllerType.Joystick)
			{
				int num = LoadJoystickData(args.controllerId);
				if (loadDataOnStart && loadJoystickAssignments && !wasJoystickEverDetected)
				{
					StartCoroutine(LoadJoystickAssignmentsDeferred());
				}
				if (loadJoystickAssignments && !deferredJoystickAssignmentLoadPending)
				{
					SaveControllerAssignments();
				}
				wasJoystickEverDetected = true;
			}
		}

		protected override void OnControllerPreDiscconnect(ControllerStatusChangedEventArgs args)
		{
			if (isEnabled && args.controllerType == ControllerType.Joystick)
			{
				SaveJoystickData(args.controllerId);
			}
		}

		protected override void OnControllerDisconnected(ControllerStatusChangedEventArgs args)
		{
			if (isEnabled && loadControllerAssignments)
			{
				SaveControllerAssignments();
			}
		}

		private int LoadAll()
		{
			int num = 0;
			if (loadControllerAssignments && LoadControllerAssignmentsNow())
			{
				num++;
			}
			IList<Player> allPlayers = ReInput.players.AllPlayers;
			for (int i = 0; i < allPlayers.Count; i++)
			{
				num += LoadPlayerDataNow(allPlayers[i]);
			}
			return num + LoadAllJoystickCalibrationData();
		}

		private int LoadPlayerDataNow(int playerId)
		{
			return LoadPlayerDataNow(ReInput.players.GetPlayer(playerId));
		}

		private int LoadPlayerDataNow(Player player)
		{
			if (player == null)
			{
				return 0;
			}
			int num = 0;
			num += LoadInputBehaviors(player.id);
			num += LoadControllerMaps(player.id, ControllerType.Keyboard, 0);
			num += LoadControllerMaps(player.id, ControllerType.Mouse, 0);
			foreach (Joystick joystick in player.controllers.Joysticks)
			{
				num += LoadControllerMaps(player.id, ControllerType.Joystick, joystick.id);
			}
			return num;
		}

		private int LoadAllJoystickCalibrationData()
		{
			int num = 0;
			IList<Joystick> joysticks = ReInput.controllers.Joysticks;
			for (int i = 0; i < joysticks.Count; i++)
			{
				num += LoadJoystickCalibrationData(joysticks[i]);
			}
			return num;
		}

		private int LoadJoystickCalibrationData(Joystick joystick)
		{
			if (joystick == null)
			{
				return 0;
			}
			return joystick.ImportCalibrationMapFromXmlString(GetJoystickCalibrationMapXml(joystick)) ? 1 : 0;
		}

		private int LoadJoystickCalibrationData(int joystickId)
		{
			return LoadJoystickCalibrationData(ReInput.controllers.GetJoystick(joystickId));
		}

		private int LoadJoystickData(int joystickId)
		{
			int num = 0;
			IList<Player> allPlayers = ReInput.players.AllPlayers;
			for (int i = 0; i < allPlayers.Count; i++)
			{
				Player player = allPlayers[i];
				if (player.controllers.ContainsController(ControllerType.Joystick, joystickId))
				{
					num += LoadControllerMaps(player.id, ControllerType.Joystick, joystickId);
				}
			}
			return num + LoadJoystickCalibrationData(joystickId);
		}

		private int LoadControllerDataNow(int playerId, ControllerType controllerType, int controllerId)
		{
			int num = 0;
			num += LoadControllerMaps(playerId, controllerType, controllerId);
			return num + LoadControllerDataNow(controllerType, controllerId);
		}

		private int LoadControllerDataNow(ControllerType controllerType, int controllerId)
		{
			int num = 0;
			if (controllerType == ControllerType.Joystick)
			{
				num += LoadJoystickCalibrationData(controllerId);
			}
			return num;
		}

		private int LoadControllerMaps(int playerId, ControllerType controllerType, int controllerId)
		{
			int num = 0;
			Player player = ReInput.players.GetPlayer(playerId);
			if (player == null)
			{
				return num;
			}
			Controller controller = ReInput.controllers.GetController(controllerType, controllerId);
			if (controller == null)
			{
				return num;
			}
			if (controllerType == ControllerType.Joystick)
			{
				Debug.Log("LoadControllerMaps Joystick defaults");
				player.controllers.maps.LoadDefaultMaps(ControllerType.Joystick);
				return 0;
			}
			List<SavedControllerMapData> allControllerMapsXml = GetAllControllerMapsXml(player, true, controller);
			if (allControllerMapsXml.Count == 0)
			{
				return num;
			}
			num += player.controllers.maps.AddMapsFromXml(controllerType, controllerId, SavedControllerMapData.GetXmlStringList(allControllerMapsXml));
			AddDefaultMappingsForNewActions(player, allControllerMapsXml, controllerType, controllerId);
			return num;
		}

		private int LoadInputBehaviors(int playerId)
		{
			Player player = ReInput.players.GetPlayer(playerId);
			if (player == null)
			{
				return 0;
			}
			int num = 0;
			IList<InputBehavior> inputBehaviors = ReInput.mapping.GetInputBehaviors(player.id);
			for (int i = 0; i < inputBehaviors.Count; i++)
			{
				num += LoadInputBehaviorNow(player, inputBehaviors[i]);
			}
			return num;
		}

		private int LoadInputBehaviorNow(int playerId, int behaviorId)
		{
			Player player = ReInput.players.GetPlayer(playerId);
			if (player == null)
			{
				return 0;
			}
			InputBehavior inputBehavior = ReInput.mapping.GetInputBehavior(playerId, behaviorId);
			if (inputBehavior == null)
			{
				return 0;
			}
			return LoadInputBehaviorNow(player, inputBehavior);
		}

		private int LoadInputBehaviorNow(Player player, InputBehavior inputBehavior)
		{
			if (player == null || inputBehavior == null)
			{
				return 0;
			}
			string inputBehaviorXml = GetInputBehaviorXml(player, inputBehavior.id);
			if (inputBehaviorXml == null || inputBehaviorXml == string.Empty)
			{
				return 0;
			}
			return inputBehavior.ImportXmlString(inputBehaviorXml) ? 1 : 0;
		}

		private bool LoadControllerAssignmentsNow()
		{
			try
			{
				ControllerAssignmentSaveInfo controllerAssignmentSaveInfo = LoadControllerAssignmentData();
				if (controllerAssignmentSaveInfo == null)
				{
					return false;
				}
				if (loadKeyboardAssignments || loadMouseAssignments)
				{
					LoadKeyboardAndMouseAssignmentsNow(controllerAssignmentSaveInfo);
				}
				if (loadJoystickAssignments)
				{
					LoadJoystickAssignmentsNow(controllerAssignmentSaveInfo);
				}
			}
			catch
			{
			}
			return true;
		}

		private bool LoadKeyboardAndMouseAssignmentsNow(ControllerAssignmentSaveInfo data)
		{
			try
			{
				if (data == null && (data = LoadControllerAssignmentData()) == null)
				{
					return false;
				}
				foreach (Player allPlayer in ReInput.players.AllPlayers)
				{
					if (data.ContainsPlayer(allPlayer.id))
					{
						ControllerAssignmentSaveInfo.PlayerInfo playerInfo = data.players[data.IndexOfPlayer(allPlayer.id)];
						if (loadKeyboardAssignments)
						{
							allPlayer.controllers.hasKeyboard = playerInfo.hasKeyboard;
						}
						if (loadMouseAssignments)
						{
							allPlayer.controllers.hasMouse = playerInfo.hasMouse;
						}
					}
				}
			}
			catch
			{
			}
			return true;
		}

		private bool LoadJoystickAssignmentsNow(ControllerAssignmentSaveInfo data)
		{
			try
			{
				if (ReInput.controllers.joystickCount == 0)
				{
					return false;
				}
				if (data == null && (data = LoadControllerAssignmentData()) == null)
				{
					return false;
				}
				foreach (Player allPlayer in ReInput.players.AllPlayers)
				{
					allPlayer.controllers.ClearControllersOfType(ControllerType.Joystick);
				}
				List<JoystickAssignmentHistoryInfo> list = ((!loadJoystickAssignments) ? null : new List<JoystickAssignmentHistoryInfo>());
				foreach (Player allPlayer2 in ReInput.players.AllPlayers)
				{
					if (!data.ContainsPlayer(allPlayer2.id))
					{
						continue;
					}
					ControllerAssignmentSaveInfo.PlayerInfo playerInfo = data.players[data.IndexOfPlayer(allPlayer2.id)];
					for (int i = 0; i < playerInfo.joystickCount; i++)
					{
						ControllerAssignmentSaveInfo.JoystickInfo joystickInfo = playerInfo.joysticks[i];
						if (joystickInfo == null)
						{
							continue;
						}
						Joystick joystick = FindJoystickPrecise(joystickInfo);
						if (joystick != null)
						{
							if (list.Find((JoystickAssignmentHistoryInfo x) => x.joystick == joystick) == null)
							{
								list.Add(new JoystickAssignmentHistoryInfo(joystick, joystickInfo.id));
							}
							allPlayer2.controllers.AddController(joystick, false);
						}
					}
				}
				if (allowImpreciseJoystickAssignmentMatching)
				{
					foreach (Player allPlayer3 in ReInput.players.AllPlayers)
					{
						if (!data.ContainsPlayer(allPlayer3.id))
						{
							continue;
						}
						ControllerAssignmentSaveInfo.PlayerInfo playerInfo2 = data.players[data.IndexOfPlayer(allPlayer3.id)];
						for (int num = 0; num < playerInfo2.joystickCount; num++)
						{
							ControllerAssignmentSaveInfo.JoystickInfo joystickInfo2 = playerInfo2.joysticks[num];
							if (joystickInfo2 == null)
							{
								continue;
							}
							Joystick joystick2 = null;
							int num2 = list.FindIndex((JoystickAssignmentHistoryInfo x) => x.oldJoystickId == joystickInfo2.id);
							if (num2 >= 0)
							{
								joystick2 = list[num2].joystick;
							}
							else
							{
								List<Joystick> matches;
								if (!TryFindJoysticksImprecise(joystickInfo2, out matches))
								{
									continue;
								}
								foreach (Joystick match in matches)
								{
									if (list.Find((JoystickAssignmentHistoryInfo x) => x.joystick == match) != null)
									{
										continue;
									}
									joystick2 = match;
									break;
								}
								if (joystick2 == null)
								{
									continue;
								}
								list.Add(new JoystickAssignmentHistoryInfo(joystick2, joystickInfo2.id));
							}
							allPlayer3.controllers.AddController(joystick2, false);
						}
					}
				}
			}
			catch
			{
			}
			if (ReInput.configuration.autoAssignJoysticks)
			{
				ReInput.controllers.AutoAssignJoysticks();
			}
			return true;
		}

		private ControllerAssignmentSaveInfo LoadControllerAssignmentData()
		{
			try
			{
				if (!PlayerPrefs.HasKey(playerPrefsKey_controllerAssignments))
				{
					return null;
				}
				string text = PlayerPrefs.GetString(playerPrefsKey_controllerAssignments);
				if (string.IsNullOrEmpty(text))
				{
					return null;
				}
				ControllerAssignmentSaveInfo controllerAssignmentSaveInfo = JsonParser.FromJson<ControllerAssignmentSaveInfo>(text);
				if (controllerAssignmentSaveInfo == null || controllerAssignmentSaveInfo.playerCount == 0)
				{
					return null;
				}
				return controllerAssignmentSaveInfo;
			}
			catch
			{
				return null;
			}
		}

		private IEnumerator LoadJoystickAssignmentsDeferred()
		{
			deferredJoystickAssignmentLoadPending = true;
			yield return new WaitForEndOfFrame();
			if (ReInput.isReady)
			{
				if (LoadJoystickAssignmentsNow(null))
				{
				}
				SaveControllerAssignments();
				deferredJoystickAssignmentLoadPending = false;
			}
		}

		private void SaveAll()
		{
			IList<Player> allPlayers = ReInput.players.AllPlayers;
			for (int i = 0; i < allPlayers.Count; i++)
			{
				SavePlayerDataNow(allPlayers[i]);
			}
			SaveAllJoystickCalibrationData();
			if (loadControllerAssignments)
			{
				SaveControllerAssignments();
			}
			PlayerPrefs.Save();
		}

		private void SavePlayerDataNow(int playerId)
		{
			SavePlayerDataNow(ReInput.players.GetPlayer(playerId));
			PlayerPrefs.Save();
		}

		private void SavePlayerDataNow(Player player)
		{
			if (player != null)
			{
				PlayerSaveData saveData = player.GetSaveData(true);
				SaveInputBehaviors(player, saveData);
				SaveControllerMaps(player, saveData);
			}
		}

		private void SaveAllJoystickCalibrationData()
		{
			IList<Joystick> joysticks = ReInput.controllers.Joysticks;
			for (int i = 0; i < joysticks.Count; i++)
			{
				SaveJoystickCalibrationData(joysticks[i]);
			}
		}

		private void SaveJoystickCalibrationData(int joystickId)
		{
			SaveJoystickCalibrationData(ReInput.controllers.GetJoystick(joystickId));
		}

		private void SaveJoystickCalibrationData(Joystick joystick)
		{
			if (joystick != null)
			{
				JoystickCalibrationMapSaveData calibrationMapSaveData = joystick.GetCalibrationMapSaveData();
				string joystickCalibrationMapPlayerPrefsKey = GetJoystickCalibrationMapPlayerPrefsKey(joystick);
				PlayerPrefs.SetString(joystickCalibrationMapPlayerPrefsKey, calibrationMapSaveData.map.ToXmlString());
			}
		}

		private void SaveJoystickData(int joystickId)
		{
			IList<Player> allPlayers = ReInput.players.AllPlayers;
			for (int i = 0; i < allPlayers.Count; i++)
			{
				Player player = allPlayers[i];
				if (player.controllers.ContainsController(ControllerType.Joystick, joystickId))
				{
					SaveControllerMaps(player.id, ControllerType.Joystick, joystickId);
				}
			}
			SaveJoystickCalibrationData(joystickId);
		}

		private void SaveControllerDataNow(int playerId, ControllerType controllerType, int controllerId)
		{
			SaveControllerMaps(playerId, controllerType, controllerId);
			SaveControllerDataNow(controllerType, controllerId);
			PlayerPrefs.Save();
		}

		private void SaveControllerDataNow(ControllerType controllerType, int controllerId)
		{
			if (controllerType == ControllerType.Joystick)
			{
				SaveJoystickCalibrationData(controllerId);
			}
			PlayerPrefs.Save();
		}

		private void SaveControllerMaps(Player player, PlayerSaveData playerSaveData)
		{
			foreach (ControllerMapSaveData allControllerMapSaveDatum in playerSaveData.AllControllerMapSaveData)
			{
				SaveControllerMap(player, allControllerMapSaveDatum);
			}
		}

		private void SaveControllerMaps(int playerId, ControllerType controllerType, int controllerId)
		{
			Player player = ReInput.players.GetPlayer(playerId);
			if (player == null || !player.controllers.ContainsController(controllerType, controllerId))
			{
				return;
			}
			ControllerMapSaveData[] mapSaveData = player.controllers.maps.GetMapSaveData(controllerType, controllerId, true);
			if (mapSaveData != null)
			{
				for (int i = 0; i < mapSaveData.Length; i++)
				{
					SaveControllerMap(player, mapSaveData[i]);
				}
			}
		}

		private void SaveControllerMap(Player player, ControllerMapSaveData saveData)
		{
			string controllerMapPlayerPrefsKey = GetControllerMapPlayerPrefsKey(player, saveData.controller, saveData.categoryId, saveData.layoutId);
			PlayerPrefs.SetString(controllerMapPlayerPrefsKey, saveData.map.ToXmlString());
			controllerMapPlayerPrefsKey = GetControllerMapKnownActionIdsPlayerPrefsKey(player, saveData.controller, saveData.categoryId, saveData.layoutId);
			PlayerPrefs.SetString(controllerMapPlayerPrefsKey, GetAllActionIdsString());
		}

		private void SaveInputBehaviors(Player player, PlayerSaveData playerSaveData)
		{
			if (player != null)
			{
				InputBehavior[] inputBehaviors = playerSaveData.inputBehaviors;
				for (int i = 0; i < inputBehaviors.Length; i++)
				{
					SaveInputBehaviorNow(player, inputBehaviors[i]);
				}
			}
		}

		private void SaveInputBehaviorNow(int playerId, int behaviorId)
		{
			Player player = ReInput.players.GetPlayer(playerId);
			if (player != null)
			{
				InputBehavior inputBehavior = ReInput.mapping.GetInputBehavior(playerId, behaviorId);
				if (inputBehavior != null)
				{
					SaveInputBehaviorNow(player, inputBehavior);
					PlayerPrefs.Save();
				}
			}
		}

		private void SaveInputBehaviorNow(Player player, InputBehavior inputBehavior)
		{
			if (player != null && inputBehavior != null)
			{
				string inputBehaviorPlayerPrefsKey = GetInputBehaviorPlayerPrefsKey(player, inputBehavior.id);
				PlayerPrefs.SetString(inputBehaviorPlayerPrefsKey, inputBehavior.ToXmlString());
			}
		}

		private bool SaveControllerAssignments()
		{
			try
			{
				ControllerAssignmentSaveInfo controllerAssignmentSaveInfo = new ControllerAssignmentSaveInfo(ReInput.players.allPlayerCount);
				for (int i = 0; i < ReInput.players.allPlayerCount; i++)
				{
					Player player = ReInput.players.AllPlayers[i];
					ControllerAssignmentSaveInfo.PlayerInfo playerInfo = new ControllerAssignmentSaveInfo.PlayerInfo();
					controllerAssignmentSaveInfo.players[i] = playerInfo;
					playerInfo.id = player.id;
					playerInfo.hasKeyboard = player.controllers.hasKeyboard;
					playerInfo.hasMouse = player.controllers.hasMouse;
					ControllerAssignmentSaveInfo.JoystickInfo[] array = (playerInfo.joysticks = new ControllerAssignmentSaveInfo.JoystickInfo[player.controllers.joystickCount]);
					for (int j = 0; j < player.controllers.joystickCount; j++)
					{
						Joystick joystick = player.controllers.Joysticks[j];
						ControllerAssignmentSaveInfo.JoystickInfo joystickInfo = new ControllerAssignmentSaveInfo.JoystickInfo();
						joystickInfo.instanceGuid = joystick.deviceInstanceGuid;
						joystickInfo.id = joystick.id;
						joystickInfo.hardwareIdentifier = joystick.hardwareIdentifier;
						array[j] = joystickInfo;
					}
				}
				PlayerPrefs.SetString(playerPrefsKey_controllerAssignments, JsonWriter.ToJson(controllerAssignmentSaveInfo));
				PlayerPrefs.Save();
			}
			catch
			{
			}
			return true;
		}

		private bool ControllerAssignmentSaveDataExists()
		{
			if (!PlayerPrefs.HasKey(playerPrefsKey_controllerAssignments))
			{
				return false;
			}
			string value = PlayerPrefs.GetString(playerPrefsKey_controllerAssignments);
			if (string.IsNullOrEmpty(value))
			{
				return false;
			}
			return true;
		}

		private string GetBasePlayerPrefsKey(Player player)
		{
			string text = playerPrefsKeyPrefix;
			return text + "|playerName=" + player.name;
		}

		private string GetControllerMapPlayerPrefsKey(Player player, Controller controller, int categoryId, int layoutId)
		{
			string basePlayerPrefsKey = GetBasePlayerPrefsKey(player);
			basePlayerPrefsKey += "|dataType=ControllerMap";
			basePlayerPrefsKey = basePlayerPrefsKey + "|controllerMapType=" + controller.mapTypeString;
			string text = basePlayerPrefsKey;
			basePlayerPrefsKey = text + "|categoryId=" + categoryId + "|layoutId=" + layoutId;
			basePlayerPrefsKey = basePlayerPrefsKey + "|hardwareIdentifier=" + controller.hardwareIdentifier;
			if (controller.type == ControllerType.Joystick)
			{
				basePlayerPrefsKey = basePlayerPrefsKey + "|hardwareGuid=" + ((Joystick)controller).hardwareTypeGuid.ToString();
			}
			return basePlayerPrefsKey;
		}

		private string GetControllerMapKnownActionIdsPlayerPrefsKey(Player player, Controller controller, int categoryId, int layoutId)
		{
			string basePlayerPrefsKey = GetBasePlayerPrefsKey(player);
			basePlayerPrefsKey += "|dataType=ControllerMap_KnownActionIds";
			basePlayerPrefsKey = basePlayerPrefsKey + "|controllerMapType=" + controller.mapTypeString;
			string text = basePlayerPrefsKey;
			basePlayerPrefsKey = text + "|categoryId=" + categoryId + "|layoutId=" + layoutId;
			basePlayerPrefsKey = basePlayerPrefsKey + "|hardwareIdentifier=" + controller.hardwareIdentifier;
			if (controller.type == ControllerType.Joystick)
			{
				basePlayerPrefsKey = basePlayerPrefsKey + "|hardwareGuid=" + ((Joystick)controller).hardwareTypeGuid.ToString();
			}
			return basePlayerPrefsKey;
		}

		private string GetJoystickCalibrationMapPlayerPrefsKey(Joystick joystick)
		{
			string text = playerPrefsKeyPrefix;
			text += "|dataType=CalibrationMap";
			text = text + "|controllerType=" + joystick.type;
			text = text + "|hardwareIdentifier=" + joystick.hardwareIdentifier;
			return text + "|hardwareGuid=" + joystick.hardwareTypeGuid.ToString();
		}

		private string GetInputBehaviorPlayerPrefsKey(Player player, int inputBehaviorId)
		{
			string basePlayerPrefsKey = GetBasePlayerPrefsKey(player);
			basePlayerPrefsKey += "|dataType=InputBehavior";
			return basePlayerPrefsKey + "|id=" + inputBehaviorId;
		}

		private string GetControllerMapXml(Player player, Controller controller, int categoryId, int layoutId)
		{
			string controllerMapPlayerPrefsKey = GetControllerMapPlayerPrefsKey(player, controller, categoryId, layoutId);
			if (!PlayerPrefs.HasKey(controllerMapPlayerPrefsKey))
			{
				return string.Empty;
			}
			return PlayerPrefs.GetString(controllerMapPlayerPrefsKey);
		}

		private List<int> GetControllerMapKnownActionIds(Player player, Controller controller, int categoryId, int layoutId)
		{
			List<int> list = new List<int>();
			string controllerMapKnownActionIdsPlayerPrefsKey = GetControllerMapKnownActionIdsPlayerPrefsKey(player, controller, categoryId, layoutId);
			if (!PlayerPrefs.HasKey(controllerMapKnownActionIdsPlayerPrefsKey))
			{
				return list;
			}
			string text = PlayerPrefs.GetString(controllerMapKnownActionIdsPlayerPrefsKey);
			if (string.IsNullOrEmpty(text))
			{
				return list;
			}
			string[] array = text.Split(',');
			for (int i = 0; i < array.Length; i++)
			{
				int result;
				if (!string.IsNullOrEmpty(array[i]) && int.TryParse(array[i], out result))
				{
					list.Add(result);
				}
			}
			return list;
		}

		private List<SavedControllerMapData> GetAllControllerMapsXml(Player player, bool userAssignableMapsOnly, Controller controller)
		{
			List<SavedControllerMapData> list = new List<SavedControllerMapData>();
			IList<InputMapCategory> mapCategories = ReInput.mapping.MapCategories;
			for (int i = 0; i < mapCategories.Count; i++)
			{
				InputMapCategory inputMapCategory = mapCategories[i];
				if (userAssignableMapsOnly && !inputMapCategory.userAssignable)
				{
					continue;
				}
				IList<InputLayout> list2 = ReInput.mapping.MapLayouts(controller.type);
				for (int j = 0; j < list2.Count; j++)
				{
					InputLayout inputLayout = list2[j];
					string controllerMapXml = GetControllerMapXml(player, controller, inputMapCategory.id, inputLayout.id);
					if (!(controllerMapXml == string.Empty))
					{
						List<int> controllerMapKnownActionIds = GetControllerMapKnownActionIds(player, controller, inputMapCategory.id, inputLayout.id);
						list.Add(new SavedControllerMapData(controllerMapXml, controllerMapKnownActionIds));
					}
				}
			}
			return list;
		}

		private string GetJoystickCalibrationMapXml(Joystick joystick)
		{
			string joystickCalibrationMapPlayerPrefsKey = GetJoystickCalibrationMapPlayerPrefsKey(joystick);
			if (!PlayerPrefs.HasKey(joystickCalibrationMapPlayerPrefsKey))
			{
				return string.Empty;
			}
			return PlayerPrefs.GetString(joystickCalibrationMapPlayerPrefsKey);
		}

		private string GetInputBehaviorXml(Player player, int id)
		{
			string inputBehaviorPlayerPrefsKey = GetInputBehaviorPlayerPrefsKey(player, id);
			if (!PlayerPrefs.HasKey(inputBehaviorPlayerPrefsKey))
			{
				return string.Empty;
			}
			return PlayerPrefs.GetString(inputBehaviorPlayerPrefsKey);
		}

		private void AddDefaultMappingsForNewActions(Player player, List<SavedControllerMapData> savedData, ControllerType controllerType, int controllerId)
		{
			if (player == null || savedData == null)
			{
				return;
			}
			List<int> allActionIds = GetAllActionIds();
			for (int i = 0; i < savedData.Count; i++)
			{
				SavedControllerMapData savedControllerMapData = savedData[i];
				if (savedControllerMapData == null || savedControllerMapData.knownActionIds == null || savedControllerMapData.knownActionIds.Count == 0)
				{
					continue;
				}
				ControllerMap controllerMap = ControllerMap.CreateFromXml(controllerType, savedData[i].xml);
				if (controllerMap == null)
				{
					continue;
				}
				ControllerMap map = player.controllers.maps.GetMap(controllerType, controllerId, controllerMap.categoryId, controllerMap.layoutId);
				if (map == null)
				{
					continue;
				}
				ControllerMap controllerMapInstance = ReInput.mapping.GetControllerMapInstance(ReInput.controllers.GetController(controllerType, controllerId), controllerMap.categoryId, controllerMap.layoutId);
				if (controllerMapInstance == null)
				{
					continue;
				}
				List<int> list = new List<int>();
				foreach (int item in allActionIds)
				{
					if (!savedControllerMapData.knownActionIds.Contains(item))
					{
						list.Add(item);
					}
				}
				if (list.Count == 0)
				{
					continue;
				}
				foreach (ActionElementMap allMap in controllerMapInstance.AllMaps)
				{
					if (list.Contains(allMap.actionId) && !map.DoesElementAssignmentConflict(allMap))
					{
						ElementAssignment elementAssignment = new ElementAssignment(controllerType, allMap.elementType, allMap.elementIdentifierId, allMap.axisRange, allMap.keyCode, allMap.modifierKeyFlags, allMap.actionId, allMap.axisContribution, allMap.invert);
						map.CreateElementMap(elementAssignment);
					}
				}
			}
		}

		private List<int> GetAllActionIds()
		{
			List<int> list = new List<int>();
			IList<InputAction> actions = ReInput.mapping.Actions;
			for (int i = 0; i < actions.Count; i++)
			{
				list.Add(actions[i].id);
			}
			return list;
		}

		private string GetAllActionIdsString()
		{
			string text = string.Empty;
			List<int> allActionIds = GetAllActionIds();
			for (int i = 0; i < allActionIds.Count; i++)
			{
				if (i > 0)
				{
					text += ",";
				}
				text += allActionIds[i];
			}
			return text;
		}

		private Joystick FindJoystickPrecise(ControllerAssignmentSaveInfo.JoystickInfo joystickInfo)
		{
			if (joystickInfo == null)
			{
				return null;
			}
			if (joystickInfo.instanceGuid == Guid.Empty)
			{
				return null;
			}
			IList<Joystick> joysticks = ReInput.controllers.Joysticks;
			for (int i = 0; i < joysticks.Count; i++)
			{
				if (joysticks[i].deviceInstanceGuid == joystickInfo.instanceGuid)
				{
					return joysticks[i];
				}
			}
			return null;
		}

		private bool TryFindJoysticksImprecise(ControllerAssignmentSaveInfo.JoystickInfo joystickInfo, out List<Joystick> matches)
		{
			matches = null;
			if (joystickInfo == null)
			{
				return false;
			}
			if (string.IsNullOrEmpty(joystickInfo.hardwareIdentifier))
			{
				return false;
			}
			IList<Joystick> joysticks = ReInput.controllers.Joysticks;
			for (int i = 0; i < joysticks.Count; i++)
			{
				if (string.Equals(joysticks[i].hardwareIdentifier, joystickInfo.hardwareIdentifier, StringComparison.OrdinalIgnoreCase))
				{
					if (matches == null)
					{
						matches = new List<Joystick>();
					}
					matches.Add(joysticks[i]);
				}
			}
			return matches != null;
		}
	}
}