using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Xml;
using BepInEx;
using BepInEx.Configuration;
using GameEvent;
using HarmonyLib;
using UnityEngine;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyInformationalVersion("0.0.6")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.6.0")]
[module: UnverifiableCode]
namespace GhostBuster
{
	[BepInPlugin("GhostBuster", "GhostBuster", "0.0.6")]
	public class GhostBusterMod : BaseUnityPlugin
	{
		public enum GhostMode
		{
			Fastest,
			All,
			Last,
			Stored
		}

		[HarmonyPatch(typeof(Character), "SetupReplay")]
		private static class CharacterSetupReplayPatch
		{
			private static bool Prefix(Character __instance, GhostData data)
			{
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				if (!GhostFraid.ContainsValue(__instance))
				{
					return false;
				}
				if (InputReplay.Value)
				{
					__instance.Enable(false);
					__instance.replayData = data;
					__instance.isReplay = true;
					((Component)__instance).transform.position = data.GetDataForTime(0f, false).position;
					__instance.SetOutfitsFromArray(data.Outfits);
					__instance.nameTag.setNameBoxText(data.PlayerName, __instance);
					return false;
				}
				__instance.SetPlayerPlayerColliders(false, (ColliderStates)2);
				return true;
			}
		}

		[HarmonyPatch(typeof(Character), "SetNonLocalColliderMode")]
		private static class CharacterReplaySetNonLocalColliderModePatch
		{
			private static void Prefix(Character __instance, ref NonLocalColliderMode mode)
			{
				if (InputReplay.Value && __instance.replayData != null)
				{
					mode = (NonLocalColliderMode)1;
				}
			}
		}

		[HarmonyPatch(typeof(Character), "Update")]
		private static class CharacterUpdatePatch
		{
			private static void Postfix(Character __instance)
			{
				//IL_0116: Unknown result type (might be due to invalid IL or missing references)
				if (__instance.replayData == null)
				{
					return;
				}
				string text = "notime";
				if (__instance.replayData.lastTime != float.PositiveInfinity && __instance.replayData.lastTime > 0f)
				{
					text = HighscoreDisplayEntry.GetTimeString(__instance.replayData.lastTime);
					if (text.StartsWith("00:"))
					{
						text = text.Substring(3);
					}
				}
				else
				{
					float winTime = GetWinTime(__instance.replayData);
					if (winTime > 0f)
					{
						text = HighscoreDisplayEntry.GetTimeString(winTime);
						if (text.StartsWith("00:"))
						{
							text = text.Substring(3);
						}
						text = "~" + text;
					}
				}
				__instance.nameTag.setNameBoxText(__instance.replayData.PlayerName + " (" + text + ")", __instance);
				__instance.nameTag.currentAlpha = (ShowGhostText.Value ? 1f : 0f);
				((Graphic)__instance.nameTag.nameBox).color = Color.white;
			}
		}

		[HarmonyPatch]
		private static class CharacterReplayUpdateInvalidNowValid
		{
			private static IEnumerable<MethodBase> TargetMethods()
			{
				yield return AccessTools.Method(typeof(Character), "replayUpdate", (Type[])null, (Type[])null);
			}

			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> e)
			{
				bool done = false;
				bool start = false;
				foreach (CodeInstruction inst in e)
				{
					if (inst.opcode == OpCodes.Ldstr)
					{
						Debug.Log((object)("OpCodes.Ldstr " + inst.operand.ToString()));
					}
					if (!done && inst.opcode == OpCodes.Ldstr && inst.operand.ToString() == "Playing back an invalid keyframe!")
					{
						start = true;
						inst.opcode = OpCodes.Nop;
						inst.operand = null;
					}
					else if (start)
					{
						start = false;
						inst.opcode = OpCodes.Nop;
						done = true;
					}
					yield return inst;
				}
			}
		}

		[HarmonyPatch(typeof(Character), "replayUpdate")]
		private static class CharacterReplayUpdatePatch
		{
			private static bool Prefix(Character __instance)
			{
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				if (InputReplay.Value)
				{
					if (__instance.replayData != null && !__instance.replayPaused)
					{
						float num = Time.realtimeSinceStartup - __instance.replayStartTime;
						for (int i = __instance.replayData.lastIndex; i < __instance.replayData.dataPoints.Count; i++)
						{
							if (__instance.replayData.dataPoints[i].timestamp > num)
							{
								__instance.replayData.lastIndex = i;
								break;
							}
							ReplayDataPoint(__instance, __instance.replayData.dataPoints[i]);
						}
						__instance.fullUpdate();
					}
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(Character), "StartReplay")]
		private static class CharacterStartReplayPatch
		{
			private static bool Prefix(Character __instance)
			{
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				__instance.isGhost = true;
				if (GhostOutfis.Value)
				{
					__instance.SetOutfitsFromArray(__instance.replayData.outfits);
				}
				else
				{
					__instance.SetOutfitsFromArray(new int[6] { -1, -1, -1, -1, -1, -1 });
				}
				if (InputReplay.Value)
				{
					__instance.replayData.lastIndex = 0;
					((Component)__instance).transform.position = __instance.replayData.GetDataForTime(0f, false).position;
					__instance.isReplaying = false;
					__instance.replayStartTime = Time.realtimeSinceStartup;
					return false;
				}
				return true;
			}

			private static void Postfix(Character __instance)
			{
				if (!InputReplay.Value)
				{
					__instance.Disable(false);
					__instance.Visible = true;
				}
			}
		}

		[HarmonyPatch(typeof(GhostRecorder), "Update")]
		private static class GhostRecorderUpdatePatch
		{
			private static bool Prefix(GhostRecorder __instance, out object[] __state)
			{
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_0097: Invalid comparison between Unknown and I4
				//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
				if (__instance.previousValues != null && __instance.ghostData != null)
				{
					if (!__instance.previousValues.ContainsKey((GhostEvent)0))
					{
						__instance.previousValues[(GhostEvent)0] = "";
					}
					__state = new object[2]
					{
						__instance.ghostData.dataPoints.Count,
						__instance.previousValues[(GhostEvent)0]
					};
					__instance.previousValues.Remove((GhostEvent)0);
					object obj = __instance.previousValues[(GhostEvent)2];
					if (obj != null && (int)(AnimState)obj == 8 && __instance.ghostData.lastTime == 0f)
					{
						__instance.ghostData.lastTime = __instance.ghostData.dataPoints[__instance.ghostData.dataPoints.Count - 1].timestamp;
					}
				}
				else
				{
					__state = new object[2] { 0, "" };
				}
				return true;
			}

			private static void Postfix(GhostRecorder __instance, object[] __state)
			{
				//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0178: Unknown result type (might be due to invalid IL or missing references)
				//IL_017d: Unknown result type (might be due to invalid IL or missing references)
				if (!__instance.tracking || __instance.paused || !((Object)(object)__instance.trackedChar != (Object)null) || __instance.ghostData.lastTime != 0f)
				{
					return;
				}
				Character trackedChar = __instance.trackedChar;
				string text = trackedChar.up + "|" + trackedChar.down + "|" + trackedChar.leftInput + "|" + trackedChar.rightInput + "|" + (trackedChar.jump ? 1 : 0) + "|" + (trackedChar.suicide ? 1 : 0) + "|" + (trackedChar.sprint ? 1 : 0) + "|" + (trackedChar.dance ? 1 : 0);
				if (__state[1] as string != text)
				{
					if ((int)__state[0] != __instance.ghostData.dataPoints.Count)
					{
						GhostDataPoint val = __instance.ghostData.dataPoints[__instance.ghostData.dataPoints.Count - 1];
						((GhostDataPoint)(ref val)).AddData((GhostEvent)0, (object)text);
					}
					else
					{
						((GhostDataPoint)(ref __instance.nextDataPoint)).AddData((GhostEvent)0, (object)text);
						__instance.ghostData.AddGhostData(new GhostDataPoint(__instance.nextDataPoint));
					}
				}
				__instance.previousValues[(GhostEvent)0] = text;
			}
		}

		[HarmonyPatch(typeof(ChallengeScoreboard), "ShowNewResult")]
		private static class ChallengeScoreboardShowNewResultPatch
		{
			private static void Prefix(ChallengeScoreboard __instance)
			{
				foreach (GamePlayer item in ((GameControl)__instance.challengeController).PlayerQueue)
				{
					GhostRecorder val = item?.CharacterInstance?.ReplayRecorder;
					if (!((Object)(object)val != (Object)null))
					{
						continue;
					}
					string currentLevelName = GetCurrentLevelName();
					GhostData copy = val.ghostData.GetCopy();
					if (__instance.challengeController.playerEndTimes.ContainsKey(item))
					{
						copy.lastTime = __instance.challengeController.playerEndTimes[item];
					}
					Debug.Log((object)("add replay for level: " + currentLevelName));
					if (!Replays.ContainsKey(currentLevelName))
					{
						Replays.Add(currentLevelName, new List<GhostData> { copy });
					}
					else
					{
						Replays[currentLevelName].Add(copy);
					}
					List<GhostData> list = Replays[currentLevelName].ToList();
					if (Replays[currentLevelName].Count > MaxGhostNumber.Value)
					{
						IOrderedEnumerable<GhostData> source = SortGhostByTime(Replays[currentLevelName]);
						GhostData val2 = source.Last();
						if (SelectedGhostMode.Value == GhostMode.Last)
						{
							val2 = Replays[currentLevelName][0];
						}
						int key = Animator.StringToHash(val2.printData());
						if (GhostFraid.ContainsKey(key))
						{
							Object.Destroy((Object)(object)((Component)GhostFraid[key]).gameObject);
							GhostFraid.Remove(key);
						}
						Replays[currentLevelName].Remove(val2);
					}
				}
			}
		}

		[HarmonyPatch(typeof(ChallengeControl), "SetupStart")]
		private static class ChallengeControlSetupStartPatch
		{
			private static void Prefix(ChallengeControl __instance)
			{
				GhostFraid = new Dictionary<int, Character>();
			}

			private static void Postfix(ChallengeControl __instance)
			{
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				foreach (GamePlayer item in ((GameControl)__instance).PlayerQueue)
				{
					if (!Object.op_Implicit((Object)(object)item.CharacterInstance.ReplayRecorder))
					{
						GhostRecorder component = new GameObject("Ghost recorder - " + ((object)Unsafe.As<Animals, Animals>(ref item.PickedAnimal)/*cast due to .constrained prefix*/).ToString(), new Type[1] { typeof(GhostRecorder) }).GetComponent<GhostRecorder>();
						component.TrackCharacter(item.CharacterInstance);
						item.CharacterInstance.ReplayRecorder = component;
						Character val = Object.Instantiate<Character>(((GameControl)__instance).CharacterPrefab);
						((Object)((Component)val).gameObject).name = ((object)Unsafe.As<Animals, Animals>(ref item.PickedAnimal)/*cast due to .constrained prefix*/).ToString() + " (ghost)";
						val.NetworkCharacterSprite = item.PickedAnimal;
						val.SetOutfitsFromArray(item.characterOutfitsList);
						val.NetworknetworkNumber = 0;
						val.NetworklocalNumber = 0;
						val.isReplay = true;
						val.Disable(true);
						val.NetworkFindPlayerOnSpawn = false;
						val.Networkpicked = true;
						item.CharacterInstance.ReplayCharacter = val;
					}
				}
			}
		}

		[HarmonyPatch(typeof(ChallengeControl), "DoPlayMode")]
		private static class ChallengeControlDoPlayModePatch
		{
			private static void Postfix(ChallengeControl __instance)
			{
				if (!__instance.runStarted || !GameSettings.GetInstance().DebugChallengeGhosts)
				{
					return;
				}
				foreach (GamePlayer item in ((GameControl)__instance).PlayerQueue)
				{
					GhostRecorder replayRecorder = item.CharacterInstance.ReplayRecorder;
					replayRecorder.PauseTracking();
					replayRecorder.UpdateCharacter();
					item.CharacterInstance.ReplayCharacter.SetupReplay(replayRecorder.CurrentGhostData.GetCopy());
				}
			}
		}

		[HarmonyPatch(typeof(ChallengeControl), "startRun")]
		private static class ChallengeControlStartRunPatch
		{
			private static void Postfix(ChallengeControl __instance)
			{
				if (GameSettings.GetInstance().DebugChallengeGhosts)
				{
					foreach (GamePlayer item in ((GameControl)__instance).PlayerQueue)
					{
						GhostRecorder replayRecorder = item.CharacterInstance.ReplayRecorder;
						Character replayCharacter = item.CharacterInstance.ReplayCharacter;
						if (!replayRecorder.IsTracking)
						{
							replayRecorder.StartTracking(item.CharacterInstance);
						}
						if (replayRecorder.IsPaused)
						{
							replayRecorder.ResumeTracking();
							replayRecorder.Reset();
						}
						if (replayCharacter.HasReplayData)
						{
							replayCharacter.Enable(false);
							replayCharacter.StartReplay();
						}
					}
				}
				string currentLevelName = GetCurrentLevelName();
				if (ShowGhosts.Value && ((SelectedGhostMode.Value != GhostMode.Stored && Replays.ContainsKey(currentLevelName)) || (SelectedGhostMode.Value == GhostMode.Stored && StoredReplays.ContainsKey(currentLevelName))))
				{
					switch (SelectedGhostMode.Value)
					{
					case GhostMode.All:
					{
						foreach (GhostData item2 in Replays[currentLevelName])
						{
							int key2 = Animator.StringToHash(item2.printData());
							if (GhostFraid.ContainsKey(key2))
							{
								Character val2 = GhostFraid[key2];
								val2.StartReplay();
							}
							else
							{
								AddReplayGhost(item2);
							}
						}
						break;
					}
					case GhostMode.Fastest:
						ClearReplayGhosts();
						AddReplayGhost(SortGhostByTime(Replays[currentLevelName]).First());
						break;
					case GhostMode.Last:
						ClearReplayGhosts();
						AddReplayGhost(Replays[currentLevelName][Replays[currentLevelName].Count - 1]);
						break;
					case GhostMode.Stored:
						if (StoredReplays.Count != 0)
						{
							foreach (GhostData item3 in StoredReplays[currentLevelName])
							{
								int key = Animator.StringToHash(item3.printData());
								if (GhostFraid.ContainsKey(key) && Object.op_Implicit((Object)(object)GhostFraid[key]))
								{
									Character val = GhostFraid[key];
									val.StartReplay();
								}
								else
								{
									AddReplayGhost(item3);
								}
							}
							break;
						}
						ClearReplayGhosts();
						break;
					}
				}
				else
				{
					ClearReplayGhosts();
				}
			}
		}

		[HarmonyPatch(typeof(Character), "ReceiveEvent")]
		private static class CharacterReceiveEventPatch
		{
			private static void Prefix(Character __instance, InputEvent e)
			{
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_0117: Unknown result type (might be due to invalid IL or missing references)
				if (Object.op_Implicit((Object)(object)__instance.ReplayRecorder) && __instance.ReplayRecorder.IsTracking)
				{
					GhostDataPoint val = default(GhostDataPoint);
					((GhostDataPoint)(ref val))..ctor(Time.realtimeSinceStartup - __instance.ReplayRecorder.timeOffset, ((Component)__instance).transform.position, true);
					val.eventVals.Add((GhostEvent)0, ((object)e.Key/*cast due to .constrained prefix*/).ToString() + ":" + e.Valuef + ":" + e.Valueb + ":" + e.Changed);
					val.eventVals.Add((GhostEvent)2, __instance.CurrentAnim);
					val.eventVals.Add((GhostEvent)3, __instance.SecondaryAnim);
					val.eventVals.Add((GhostEvent)4, __instance.FlipSpriteX);
					__instance.ReplayRecorder.ghostData.AddGhostData(val);
				}
			}
		}

		[HarmonyPatch(typeof(ChallengeControl), "handleEvent")]
		private static class ChallengeControlHandleEventPatch
		{
			private static void PostFix(ChallengeControl __instance, GameEvent e)
			{
				if (!(((object)e).GetType() == typeof(PauseEvent)))
				{
					return;
				}
				PauseEvent val = (PauseEvent)(object)((e is PauseEvent) ? e : null);
				if (!GameSettings.GetInstance().DebugChallengeGhosts)
				{
					return;
				}
				if (((PauseEvent)((e is PauseEvent) ? e : null)).Paused)
				{
					foreach (GamePlayer item in ((GameControl)__instance).PlayerQueue)
					{
						Character characterInstance = item.CharacterInstance;
						if (characterInstance.ReplayRecorder.IsTracking)
						{
							characterInstance.ReplayRecorder.PauseTracking();
						}
						if (characterInstance.isReplaying)
						{
							characterInstance.PauseReplay();
						}
					}
					return;
				}
				foreach (GamePlayer item2 in ((GameControl)__instance).PlayerQueue)
				{
					Character characterInstance2 = item2.CharacterInstance;
					if (characterInstance2.ReplayRecorder.IsTracking && characterInstance2.ReplayRecorder.IsPaused)
					{
						characterInstance2.ReplayRecorder.ResumeTracking();
					}
					if (characterInstance2.isReplaying && characterInstance2.replayPaused)
					{
						characterInstance2.ResumeReplay();
					}
				}
			}
		}

		public static ConfigEntry<bool> ShowGhosts;

		public static ConfigEntry<GhostMode> SelectedGhostMode;

		public static ConfigEntry<int> MaxGhostNumber;

		public static ConfigEntry<bool> ClearStoredGhosts;

		public static ConfigEntry<bool> ShowGhostText;

		public static ConfigEntry<bool> GhostOutfis;

		public static ConfigEntry<float> GhostAlpha;

		public static ConfigEntry<bool> InputReplay;

		public static ConfigEntry<UserMsgPriority> MsgPriority;

		public static ConfigEntry<KeyCode> ToggleGhostsKey;

		public static ConfigEntry<KeyCode> SwitchGhostModeKey;

		public static ConfigEntry<KeyCode> StoreGhostDataKey;

		public static ConfigEntry<KeyCode> LoadGhostDataKey;

		public static ConfigEntry<KeyCode> ToggleGhostTextKey;

		public static ConfigEntry<KeyCode> ClearAllGhostReplaysKey;

		public static Dictionary<int, Character> GhostFraid = new Dictionary<int, Character>();

		public static Dictionary<string, List<GhostData>> Replays = new Dictionary<string, List<GhostData>>();

		public static Dictionary<string, List<GhostData>> StoredReplays = new Dictionary<string, List<GhostData>>();

		private void Awake()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			Debug.Log((object)"Let the Ghosts replay");
			GameSettings.GetInstance().DebugChallengeGhosts = true;
			new Harmony("GhostBuster").PatchAll();
			ShowGhosts = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "ShowGhosts", false, (ConfigDescription)null);
			MaxGhostNumber = ((BaseUnityPlugin)this).Config.Bind<int>("General", "MaxGhostNumber", 10, "Maximum number of ghost replays that are kept and shown in Ghost Mode ALL");
			SelectedGhostMode = ((BaseUnityPlugin)this).Config.Bind<GhostMode>("General", "SelectedGhostMode", GhostMode.Fastest, "The selected Replay Ghost Mode");
			ClearStoredGhosts = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "ClearStoredGhosts", false, "Remove stored ghost replays when new one is loaded");
			ShowGhostText = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "ShowGhostText", true, "Display text box above ghosts with name and time");
			GhostOutfis = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "GhostOutfis", true, "Show outfits for ghost replays");
			GhostAlpha = ((BaseUnityPlugin)this).Config.Bind<float>("General", "GhostAlpha", 0.45f, "Set the alpha/transparency of ghosts. [1: solid, ..., 0: invisible]");
			InputReplay = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "InputReplay", false, "Record and replay from user input");
			GameSettings.GetInstance().ghostAlpha = GhostAlpha.Value;
			MsgPriority = ((BaseUnityPlugin)this).Config.Bind<UserMsgPriority>("GUI", "MsgPriority", (UserMsgPriority)1, "Display GUI messages: hi = show in middle, lo = show bottom right");
			ToggleGhostsKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("INPUT", "ToggleGhostsKey", (KeyCode)103, "Keybinding: Toggle Ghosts on or off");
			LoadGhostDataKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("INPUT", "LoadGhostDataKey", (KeyCode)108, "Keybinding: Toggle Ghost Modes");
			StoreGhostDataKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("INPUT", "StoreGhostDataKey", (KeyCode)107, "Keybinding: Load stored data from clipboard");
			SwitchGhostModeKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("INPUT", "SwitchGhostModeKey", (KeyCode)104, "Keybinding: Store ghost data in clipboard");
			ToggleGhostTextKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("INPUT", "ToggleGhostTextKey", (KeyCode)110, "Keybinding: Toggle text above ghosts");
			ClearAllGhostReplaysKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("INPUT", "ClearAllGhostReplays", (KeyCode)120, "Keybinding: Clear all GhostReplay data");
		}

		private static float GetWinTime(GhostData data)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Invalid comparison between Unknown and I4
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			foreach (GhostDataPoint dataPoint in data.dataPoints)
			{
				if (dataPoint.eventVals.ContainsKey((GhostEvent)2))
				{
					object obj = dataPoint.eventVals[(GhostEvent)2];
					if (obj != null && (int)(AnimState)obj == 8)
					{
						return dataPoint.timestamp;
					}
				}
			}
			return -1f;
		}

		public static T FindObject<T>(string name) where T : Object
		{
			T result = default(T);
			T[] array = Resources.FindObjectsOfTypeAll<T>();
			foreach (T val in array)
			{
				if (((Object)val).name == name)
				{
					return val;
				}
			}
			return result;
		}

		private static Character AddReplayGhost(GhostData data)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			Character val = Object.Instantiate<Character>(GhostBusterMod.FindObject<Character>("NotAMeatboy"));
			val.CharacterSprite = data.animal;
			int key = Animator.StringToHash(data.printData());
			GhostFraid.Add(key, val);
			((Object)((Component)val).gameObject).name = ((object)Unsafe.As<Animals, Animals>(ref data.animal)/*cast due to .constrained prefix*/).ToString() + " (ghost)";
			val.SetSprites(data.animal);
			int[] array = new int[6];
			for (int i = 0; i < array.Length; i++)
			{
				if (i < data.outfits.Length)
				{
					array[i] = data.outfits[i];
				}
				else
				{
					array[i] = -1;
				}
				Debug.Log((object)("clean_outfits[i] " + array[i]));
			}
			data.outfits = array;
			val.SetOutfitsFromArray(data.outfits);
			val.NetworknetworkNumber = 0;
			val.NetworklocalNumber = 0;
			val.isReplay = true;
			val.NetworkFindPlayerOnSpawn = false;
			val.Networkpicked = true;
			val.SetupReplay(data);
			val.Enable(false);
			val.StartReplay();
			return val;
		}

		public static void ClearReplayGhosts()
		{
			foreach (Character value in GhostFraid.Values)
			{
				if (Object.op_Implicit((Object)(object)value) && Object.op_Implicit((Object)(object)((Component)value).gameObject))
				{
					Object.Destroy((Object)(object)((Component)value).gameObject);
				}
			}
			GhostFraid = new Dictionary<int, Character>();
		}

		public static void ClearAllReplayGhostsData()
		{
			ClearReplayGhosts();
			Replays = new Dictionary<string, List<GhostData>>();
			StoredReplays = new Dictionary<string, List<GhostData>>();
		}

		public static void LookUpGhostId(string ghostId)
		{
		}

		public static string GetCurrentLevelName()
		{
			string text = GameState.GetInstance().currentSnapshotInfo.snapshotCode;
			if (text == "")
			{
				text = "local_" + GameState.GetInstance().currentSnapshotInfo.snapshotName;
			}
			return text;
		}

		public static IOrderedEnumerable<GhostData> SortGhostByTime(List<GhostData> replays)
		{
			return replays.OrderBy((GhostData d) => (d.lastTime != 0f) ? d.lastTime : float.PositiveInfinity);
		}

		private static void ReplayDataPoint(Character __instance, GhostDataPoint datapoint)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Expected O, but got Unknown
			foreach (KeyValuePair<GhostEvent, object> eventVal in datapoint.eventVals)
			{
				if ((int)eventVal.Key == 0)
				{
					string text = eventVal.Value as string;
					if (text.Contains(":"))
					{
						string[] array = text.Split(new char[1] { ':' });
						__instance.ReceiveEvent(new InputEvent(-1, (InputKey)Enum.Parse(typeof(InputKey), array[0]), float.Parse(array[1]), bool.Parse(array[2]), bool.Parse(array[3])));
					}
				}
			}
		}
	}
}
namespace GhostBuster.Patches
{
	[HarmonyPatch(typeof(DancingMoverCharacterTrigger), "ProcessLocalCharacterState")]
	internal static class DancingMoverIgnoreReplayCharacterPatch
	{
		private static bool Prefix(Character character)
		{
			return (Object)(object)character == (Object)null || !character.isReplay;
		}
	}
	[HarmonyPatch(typeof(DancingMoverCharacterTrigger), "ProcessServerMessage")]
	internal static class DancingMoverIgnoreAggregateServerMessagePatch
	{
		private static bool Prefix(MsgPlatformDancing message)
		{
			if (message == null || message.PlayerNumber != 0)
			{
				return true;
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(DancingMoverCharacterTrigger), "CleanUpDisconnectedCharacters")]
	internal static class DancingMoverReplayAwareCleanupPatch
	{
		private static void Postfix(DancingMoverCharacterTrigger __instance)
		{
			int[] array = (from networkNumber in __instance.activeDancerNetworkNumbers.Concat(__instance.activeOnPlatformNetworkNumbers).Distinct()
				where !Character.AllCharacters.Any((Character character) => (Object)(object)character != (Object)null && !character.isReplay && character.networkNumber == networkNumber)
				select networkNumber).ToArray();
			bool flag = false;
			int[] array2 = array;
			foreach (int item in array2)
			{
				flag |= __instance.activeDancerNetworkNumbers.Remove(item);
				flag |= __instance.activeOnPlatformNetworkNumbers.Remove(item);
			}
			if (flag)
			{
				__instance.UpdatePlatformStateAndBroadcast();
			}
		}
	}
	[HarmonyPatch(typeof(GameState), "Update")]
	internal static class GameStateUpdatePatch
	{
		private static void Prefix(GameState __instance)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			if ((int)GameSettings.GetInstance().GameMode == 3 && !GameState.ChatSystem.ChatMode)
			{
				if (Input.GetKeyDown(GhostBusterMod.ToggleGhostsKey.Value))
				{
					ToggleGhosts();
				}
				if (Input.GetKeyDown(GhostBusterMod.SwitchGhostModeKey.Value))
				{
					SwitchGhostMode();
				}
				if ((Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)305)) && Input.GetKeyDown(GhostBusterMod.StoreGhostDataKey.Value))
				{
					StoreGhostData();
				}
				if ((Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)305)) && Input.GetKeyDown(GhostBusterMod.LoadGhostDataKey.Value))
				{
					LoadGhostData();
				}
				if ((Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)305)) && Input.GetKeyDown(GhostBusterMod.ToggleGhostTextKey.Value))
				{
					ToggleGhostText();
				}
				if ((Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)305)) && Input.GetKeyDown(GhostBusterMod.ClearAllGhostReplaysKey.Value))
				{
					ClearAllGhostReplays();
				}
			}
		}

		private static void ToggleGhosts()
		{
			GhostBusterMod.ShowGhosts.Value = !GhostBusterMod.ShowGhosts.Value;
			DisplayMessage("Show Replay Ghosts: " + (GhostBusterMod.ShowGhosts.Value ? "Enabled" : "Disabled"));
		}

		private static void ToggleGhostText()
		{
			GhostBusterMod.ShowGhostText.Value = !GhostBusterMod.ShowGhostText.Value;
			DisplayMessage("Show Ghost text: " + (GhostBusterMod.ShowGhostText.Value ? "Enabled" : "Disabled"));
		}

		private static void ClearAllGhostReplays()
		{
			GhostBusterMod.ClearAllReplayGhostsData();
			DisplayMessage("Cleared all GhostReplays!");
		}

		public static void StoreGhostData()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			XmlDocument val = new XmlDocument();
			XmlElement val2 = val.CreateElement("GhostDataExport");
			XmlAttribute val3 = val.CreateAttribute("level");
			((XmlNode)val3).Value = GhostBusterMod.GetCurrentLevelName();
			((XmlNode)val2).Attributes.Append(val3);
			((XmlNode)val).AppendChild((XmlNode)(object)val2);
			foreach (Character value in GhostBusterMod.GhostFraid.Values)
			{
				GhostRecorder val4 = new GhostRecorder();
				val4.ghostData = value.replayData;
				val4.trackedChar = value;
				byte[] bytes = val4.SerializeData();
				XmlDocument val5 = XMLFromBytes(bytes);
				if (val5 != null)
				{
					XmlNode val6 = val.ImportNode(((XmlNode)val5).FirstChild, true);
					((XmlNode)val2).AppendChild(val6);
				}
			}
			Debug.Log((object)((XmlNode)val).OuterXml);
			GUIUtility.systemCopyBuffer = ((XmlNode)val).OuterXml;
			DisplayMessage("Ghost Data stored to clipboard!");
		}

		public static XmlDocument XMLFromBytes(byte[] bytes)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			string text = Encoding.UTF8.GetString(bytes);
			Debug.Log((object)("@string " + text));
			XmlDocument val = new XmlDocument();
			val.XmlResolver = null;
			try
			{
				val.LoadXml(text);
			}
			catch (Exception ex)
			{
				Debug.LogError((object)ex.Message);
			}
			return val;
		}

		public static void EnhanceXMLData(ref XmlDocument xmlDocument, GhostData gdata)
		{
			if (xmlDocument != null && gdata != null)
			{
				XmlNodeList elementsByTagName = xmlDocument.GetElementsByTagName("CharacterInfo");
				if (elementsByTagName.Count > 0)
				{
					XmlAttribute val = xmlDocument.CreateAttribute("level");
					((XmlNode)val).Value = GhostBusterMod.GetCurrentLevelName();
					elementsByTagName[0].Attributes.Append(val);
					XmlAttribute val2 = xmlDocument.CreateAttribute("animal");
					((XmlNode)val2).Value = ((object)Unsafe.As<Animals, Animals>(ref gdata.animal)/*cast due to .constrained prefix*/).ToString();
					elementsByTagName[0].Attributes.Append(val2);
					XmlAttribute val3 = xmlDocument.CreateAttribute("lastTime");
					((XmlNode)val3).Value = gdata.lastTime.ToString();
					elementsByTagName[0].Attributes.Append(val3);
				}
			}
			else
			{
				Debug.LogError((object)("EnhanceXMLData missing xmlDocument " + ((object)xmlDocument)?.ToString() + " or c " + (object)gdata));
			}
		}

		private static void LoadGhostData()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Expected O, but got Unknown
			DisplayMessage("Loading Ghost Data from clipboard!");
			if (GhostBusterMod.ClearStoredGhosts.Value)
			{
				GhostBusterMod.StoredReplays = new Dictionary<string, List<GhostData>>();
			}
			try
			{
				XmlDocument val = new XmlDocument();
				val.XmlResolver = null;
				val.LoadXml(GUIUtility.systemCopyBuffer);
				XmlElement documentElement = val.DocumentElement;
				string text = QuickSaver.ParseAttrStr((XmlNode)(object)documentElement, "level", string.Empty);
				Debug.Log((object)("add replay for level: " + text));
				foreach (XmlElement item in documentElement.GetElementsByTagName("GhostInfo"))
				{
					XmlElement val2 = item;
					GhostData gd = new GhostData();
					XmlNodeList elementsByTagName = val2.GetElementsByTagName("CharacterInfo");
					if (elementsByTagName.Count > 0)
					{
						ParseCharacterInfo(ref gd, elementsByTagName[0]);
					}
					XmlNodeList elementsByTagName2 = val2.GetElementsByTagName("GhostData");
					if (elementsByTagName2.Count == 1)
					{
						ParseGhostDataPoints(ref gd, elementsByTagName2[0]);
						if (!GhostBusterMod.StoredReplays.ContainsKey(text))
						{
							GhostBusterMod.StoredReplays.Add(text, new List<GhostData> { gd });
						}
						else
						{
							GhostBusterMod.StoredReplays[text].Add(gd);
						}
					}
					GhostBusterMod.ClearReplayGhosts();
				}
			}
			catch (Exception ex)
			{
				DisplayMessage("Failed to parse Ghost Data: " + ex.GetType());
				Debug.LogError((object)("Failed to parse Ghost Data: " + ex));
			}
		}

		public static void ParseCharacterInfo(ref GhostData gd, XmlNode CharacterInfo)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			gd.playerName = QuickSaver.ParseAttrStr(CharacterInfo, "PlayerName", string.Empty);
			Array values = Enum.GetValues(typeof(OutfitType));
			gd.outfits = new int[values.Length];
			foreach (OutfitType item in values)
			{
				gd.outfits[item] = QuickSaver.ParseAttrInt(CharacterInfo, ((object)item/*cast due to .constrained prefix*/).ToString(), -1);
			}
			string value = QuickSaver.ParseAttrStr(CharacterInfo, "animal", string.Empty);
			gd.animal = (Animals)Enum.Parse(typeof(Animals), value);
			float lastTime = QuickSaver.ParseAttrFloat(CharacterInfo, "lastTime", float.PositiveInfinity);
			gd.lastTime = lastTime;
		}

		public static void ParseGhostDataPoints(ref GhostData gd, XmlNode ghostdataelement)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			foreach (XmlElement item in ghostdataelement.SelectNodes("datapoint"))
			{
				XmlElement val = item;
				GhostDataPoint ghostDataPoint = new GhostDataPoint
				{
					valid = true,
					timestamp = QuickSaver.ParseAttrFloat((XmlNode)(object)val, "timestamp", 0f),
					frameTimestamp = QuickSaver.ParseAttrFloat((XmlNode)(object)val, "frameTimestamp", 0f),
					position = 
					{
						x = QuickSaver.ParseAttrFloat((XmlNode)(object)val, "posX", 0f)
					},
					position = 
					{
						y = QuickSaver.ParseAttrFloat((XmlNode)(object)val, "posY", 0f)
					},
					position = 
					{
						z = QuickSaver.ParseAttrFloat((XmlNode)(object)val, "posZ", 0f)
					},
					framePosition = 
					{
						x = QuickSaver.ParseAttrFloat((XmlNode)(object)val, "framePosX", 0f)
					},
					framePosition = 
					{
						y = QuickSaver.ParseAttrFloat((XmlNode)(object)val, "framePosY", 0f)
					},
					framePosition = 
					{
						z = QuickSaver.ParseAttrFloat((XmlNode)(object)val, "framePosZ", 0f)
					},
					interpolated = QuickSaver.ParseAttrBool((XmlNode)(object)val, "interpolated", true)
				};
				ParseGhostEvents(ref ghostDataPoint, (XmlNode)(object)val);
				gd.AddGhostData(ghostDataPoint);
			}
		}

		public static void ParseGhostEvents(ref GhostDataPoint ghostDataPoint, XmlNode datapoint)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Invalid comparison between Unknown and I4
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Invalid comparison between Unknown and I4
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			ghostDataPoint.eventVals = new Dictionary<GhostEvent, object>();
			Array values = Enum.GetValues(typeof(GhostEvent));
			foreach (GhostEvent item in values)
			{
				if (datapoint.Attributes[((object)item/*cast due to .constrained prefix*/).ToString()] != null)
				{
					if ((int)item == 0)
					{
						ghostDataPoint.eventVals.Add(item, ((XmlNode)datapoint.Attributes[((object)(GhostEvent)0/*cast due to .constrained prefix*/).ToString()]).Value);
					}
					else if ((int)item == 2)
					{
						ghostDataPoint.eventVals.Add(item, QuickSaver.ParseAttrEnum<AnimState>(datapoint, ((object)item/*cast due to .constrained prefix*/).ToString(), (AnimState)0));
					}
					else if ((int)item == 3)
					{
						ghostDataPoint.eventVals.Add(item, QuickSaver.ParseAttrEnum<SecondaryAnimState>(datapoint, ((object)item/*cast due to .constrained prefix*/).ToString(), (SecondaryAnimState)0));
					}
					else if (GhostData.GetEventDataType(item) == typeof(bool))
					{
						ghostDataPoint.eventVals.Add(item, QuickSaver.ParseAttrBool(datapoint, ((object)item/*cast due to .constrained prefix*/).ToString(), false));
					}
					else if (GhostData.GetEventDataType(item) == typeof(int))
					{
						ghostDataPoint.eventVals.Add(item, QuickSaver.ParseAttrInt(datapoint, ((object)item/*cast due to .constrained prefix*/).ToString(), 0));
					}
					else if (GhostData.GetEventDataType(item) == typeof(Vector3))
					{
						float num = QuickSaver.ParseAttrFloat(datapoint, "X", 0f);
						float num2 = QuickSaver.ParseAttrFloat(datapoint, "Y", 0f);
						float num3 = QuickSaver.ParseAttrFloat(datapoint, "Z", 0f);
						ghostDataPoint.eventVals.Add(item, (object)new Vector3(num, num2, num3));
					}
				}
			}
		}

		private static void SwitchGhostMode(bool reverse = false)
		{
			int num = Enum.GetNames(typeof(GhostBusterMod.GhostMode)).Length;
			GhostBusterMod.SelectedGhostMode.Value = (GhostBusterMod.GhostMode)((int)(GhostBusterMod.SelectedGhostMode.Value + ((!reverse) ? 1 : (-1))) % num);
			if (GhostBusterMod.SelectedGhostMode.Value < GhostBusterMod.GhostMode.Fastest)
			{
				GhostBusterMod.SelectedGhostMode.Value = (GhostBusterMod.GhostMode)(num - 1);
			}
			DisplayMessage("Replay Ghost Mode: " + GhostBusterMod.SelectedGhostMode.Value);
		}

		private static void DisplayMessage(string message)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			UserMessageManager.Instance.UserMessage(message, 2f, GhostBusterMod.MsgPriority.Value, false);
		}
	}
	[HarmonyPatch(typeof(GhostRecorder), "SerializeData")]
	internal static class GhostRecorderSerializeDataPatch
	{
		private static void Postfix(GhostRecorder __instance, ref byte[] __result)
		{
			StackFrame frame = new StackTrace().GetFrame(2);
			string name = frame.GetMethod().Name;
			Debug.Log((object)("methodName2 " + name));
			XmlDocument xmlDocument = GameStateUpdatePatch.XMLFromBytes(__result);
			GameStateUpdatePatch.EnhanceXMLData(ref xmlDocument, __instance.ghostData);
			if (name == "StoreGhostData")
			{
				__result = Encoding.UTF8.GetBytes(((XmlNode)xmlDocument).OuterXml);
			}
			else
			{
				__result = QuickSaver.GetCompressedBytesFromXmlString(((XmlNode)xmlDocument).OuterXml);
			}
		}
	}
	[HarmonyPatch(typeof(QuickSaver), "GetCompressedBytesFromXmlDoc")]
	internal static class QuickSaverGetCompressedBytesFromXmlDocPatch
	{
		private static bool Prefix(QuickSaver __instance, ref XmlDocument doc, out byte[] __result)
		{
			StackFrame frame = new StackTrace().GetFrame(2);
			string name = frame.GetMethod().Name;
			Debug.Log((object)("methodName " + name));
			if (name == "SerializeData" || name == "DMD<GhostRecorder::SerializeData>")
			{
				__result = Encoding.UTF8.GetBytes(((XmlNode)doc).OuterXml);
				return false;
			}
			__result = null;
			return true;
		}
	}
}