using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using MCMP_Patch.Patches;
using TooManyEmotes;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("MCMP_Patch")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("MCMP_Patch")]
[assembly: AssemblyCopyright("Copyright ©  2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("8a2b7984-d984-496c-b2dd-30d38fee4b73")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace MCMP_Patch
{
	internal class CustomLogging
	{
		private static ManualLogSource logger;

		public static void InitLogger()
		{
			try
			{
				logger = Logger.CreateLogSource($"{((BaseUnityPlugin)Plugin.instance).Info.Metadata.Name}-{((BaseUnityPlugin)Plugin.instance).Info.Metadata.Version}");
			}
			catch
			{
				logger = Plugin.defaultLogger;
			}
		}

		public static void Log(string message)
		{
			logger.LogInfo((object)message);
		}

		public static void LogError(string message)
		{
			logger.LogError((object)message);
		}

		public static void LogWarning(string message)
		{
			logger.LogWarning((object)message);
		}

		public static bool Assert(bool condition, string failMessage)
		{
			if (!condition)
			{
				LogWarning(failMessage);
			}
			return condition;
		}
	}
	[HarmonyPatch]
	public static class EmoteAchievementManager
	{
		public enum Achievements
		{
			DominoEffect,
			SpaceIsTheBest,
			ItIsWhatItIs,
			FallGuy,
			GenerationalCrashout,
			CheddahLaden,
			JiggleJiggle,
			DoNotRedeem,
			ShouldNotHaveSaidThat,
			SixThirtyTustinAvenue,
			BirdIsTheWord,
			Firework,
			Scrambled,
			NewWheels,
			LeaveTheDoorOpen,
			LookinGood,
			CreditDreams,
			TheShipGuy,
			HotToGo,
			SleepDialysisDemon,
			SeeYaLater,
			XmasInHarlem
		}

		public static Dictionary<Achievements, (string, string)> EmoteAchievements = new Dictionary<Achievements, (string, string)>();

		public static void RegisterEmoteAchievement(Achievements achievementName, string emoteName, string achievementText)
		{
			EmoteAchievements.Add(achievementName, (emoteName, achievementText));
		}

		private static (string, string) GetAchievementData(Achievements achievementName)
		{
			if (EmoteAchievements.TryGetValue(achievementName, out var value))
			{
				return value;
			}
			return (null, null);
		}

		public static void RegisterAchievements()
		{
			RegisterEmoteAchievement(Achievements.DominoEffect, "dancin'_domino", "Domino Effect");
			RegisterEmoteAchievement(Achievements.SpaceIsTheBest, "planetary_vibes", "Space Is the Best");
			RegisterEmoteAchievement(Achievements.ItIsWhatItIs, "go_with_the_flow", "It Is What It Is");
			RegisterEmoteAchievement(Achievements.FallGuy, "smug_dance", "Fall Guy");
			RegisterEmoteAchievement(Achievements.GenerationalCrashout, "get_down", "Generational Crashout");
			RegisterEmoteAchievement(Achievements.CheddahLaden, "hit_it", "Cheddah Laden");
			RegisterEmoteAchievement(Achievements.JiggleJiggle, "jiggle_jiggle", "Jiggle Jiggle");
			RegisterEmoteAchievement(Achievements.DoNotRedeem, "sad_trombone", "Do Not Redeem!");
			RegisterEmoteAchievement(Achievements.ShouldNotHaveSaidThat, "socks", "Should Not Have Said That");
			RegisterEmoteAchievement(Achievements.SixThirtyTustinAvenue, "stuck", "Welcome to 630 Tustin Ave.");
			RegisterEmoteAchievement(Achievements.BirdIsTheWord, "bird_is_the_word", "Bird Is the Word");
			RegisterEmoteAchievement(Achievements.Scrambled, "chicken_wing_it", "Scrambled!");
			RegisterEmoteAchievement(Achievements.NewWheels, "freedom_wheels", "New Wheels");
			RegisterEmoteAchievement(Achievements.LeaveTheDoorOpen, "leave_the_door_open", "Leave The Door Open");
			RegisterEmoteAchievement(Achievements.LookinGood, "looking_good", "Lookin' Good!");
			RegisterEmoteAchievement(Achievements.HotToGo, "get_hot", "Hot To Go!");
			RegisterEmoteAchievement(Achievements.SleepDialysisDemon, "boo'd_up_groove", "Sleep Dialysis Demon");
			RegisterEmoteAchievement(Achievements.SeeYaLater, "bye_bye_bye", "See Ya Later!");
			RegisterEmoteAchievement(Achievements.XmasInHarlem, "all_i_want_for_christmas", "Christmas in Harlem");
			RegisterEmoteAchievement(Achievements.CreditDreams, "lucid_dreams", "Credit Dreams...");
			RegisterEmoteAchievement(Achievements.TheShipGuy, "smooth_operator", "The Ship Guy");
			CustomLogging.Log("Registered " + EmoteAchievements.Count + " emote achievements");
		}

		[HarmonyPatch(typeof(PlayerControllerB), "ConnectClientToPlayerObject")]
		[HarmonyPostfix]
		public static void Init()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			if (HelperTools.IsClient)
			{
				HelperTools.PatchNetworkManager.CustomMessagingManager.RegisterNamedMessageHandler("MCMP_Patch.OnUnlockEmoteClientRpc", new HandleNamedMessageDelegate(OnUnlockEmoteClientRpc));
			}
		}

		public static void SyncEmoteUnlockWithClients(int emoteId)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: 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)
			int num = 2;
			FastBufferWriter val = default(FastBufferWriter);
			((FastBufferWriter)(ref val))..ctor(num, (Allocator)2, -1);
			short num2 = (short)emoteId;
			((FastBufferWriter)(ref val)).WriteValue<short>(ref num2, default(ForPrimitives));
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val2 in allPlayerScripts)
			{
				HelperTools.PatchNetworkManager.CustomMessagingManager.SendNamedMessage("MCMP_Patch.OnUnlockEmoteClientRpc", val2.playerClientId, val, (NetworkDelivery)3);
			}
		}

		private static void OnUnlockEmoteClientRpc(ulong clientId, FastBufferReader reader)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (HelperTools.IsClient)
			{
				short num = default(short);
				((FastBufferReader)(ref reader)).ReadValue<short>(ref num, default(ForPrimitives));
				if (!SessionManager.IsEmoteUnlocked(EmotesManager.allUnlockableEmotes[num], HelperTools.LocalPlayerController.playerUsername))
				{
					SessionManager.UnlockEmoteLocal((int)num, false, HelperTools.LocalPlayerController.playerUsername);
				}
			}
		}

		public static void TryUnlockEmoteAchievement(Achievements achievement, string playerUsername, bool serverUnlock = false)
		{
			var (text, achievementName) = GetAchievementData(achievement);
			if (text == null)
			{
				CustomLogging.LogWarning("Invalid emote ID for achievement " + achievement);
				return;
			}
			UnlockableEmote val = EmotesManager.allUnlockableEmotesDict[text];
			if (!SessionManager.IsEmoteUnlocked(text, playerUsername))
			{
				SessionManager.UnlockEmoteLocal(val, false, playerUsername);
				AddAchievement(achievementName, serverUnlock ? "All employees" : playerUsername);
				HelperTools.AddChatMessage(val.displayNameColorCoded + " emote unlocked!");
			}
			if (serverUnlock)
			{
				SyncEmoteUnlockWithClients(val.emoteId);
			}
		}

		private static void AddAchievement(string achievementName, string playerUsername)
		{
			HelperTools.AddChatMessage(string.Concat("<color=yellow>" + playerUsername + " unlocked an achievement:</color> ", achievementName));
		}
	}
	internal static class HelperTools
	{
		public static NetworkManager PatchNetworkManager => NetworkManager.Singleton;

		public static bool IsClient => PatchNetworkManager.IsClient;

		public static bool IsServer => PatchNetworkManager.IsServer;

		public static bool IsHost => PatchNetworkManager.IsHost;

		public static PlayerControllerB LocalPlayerController => StartOfRound.Instance?.localPlayerController;

		public static void AddChatMessage(string text)
		{
			HUDManager.Instance.AddTextToChatOnServer(text, -1);
		}
	}
	[BepInPlugin("Vijuhas.MCMP_Patch", "MCMP_Patch", "1.1.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		private readonly Harmony harmony = new Harmony("Vijuhas.MCMP_Patch");

		public static Plugin instance;

		public static ManualLogSource defaultLogger => ((BaseUnityPlugin)instance).Logger;

		private void Awake()
		{
			if ((Object)(object)instance == (Object)null)
			{
				instance = this;
			}
			CustomLogging.InitLogger();
			EmoteAchievementManager.RegisterAchievements();
			harmony.PatchAll(typeof(Plugin));
			harmony.PatchAll(typeof(EmoteAchievementManager));
			harmony.PatchAll(typeof(CauseOfDeathPatch));
			harmony.PatchAll(typeof(TerminalPatch));
			harmony.PatchAll(typeof(GrabbableObjectGrabItemPatch));
			harmony.PatchAll(typeof(GrabbableObjectBroughtToShipPatch));
			harmony.PatchAll(typeof(MouthDogAIPatch));
			harmony.PatchAll(typeof(EntranceTeleportPatch));
			harmony.PatchAll(typeof(DepositItemsDeskPatch));
			harmony.PatchAll(typeof(GiantKiwiAIPatch));
			harmony.PatchAll(typeof(VehicleControllerPatch));
			harmony.PatchAll(typeof(DressGirlAIPatch));
			CustomLogging.Log("Vijuhas.MCMP_Patch has loaded successfully.");
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "Vijuhas.MCMP_Patch";

		public const string PLUGIN_NAME = "MCMP_Patch";

		public const string PLUGIN_VERSION = "1.1.1";
	}
}
namespace MCMP_Patch.Patches
{
	[HarmonyPatch(typeof(DepositItemsDesk), "Attack")]
	internal class DepositItemsDeskPatch
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			string playerUsername = GameNetworkManager.Instance.localPlayerController.playerUsername;
			EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.DoNotRedeem, playerUsername);
		}
	}
	[HarmonyPatch(typeof(DressGirlAI), "BeginChasing")]
	internal class DressGirlAIPatch
	{
		[HarmonyPostfix]
		private static void Postfix(DressGirlAI __instance)
		{
			if ((Object)(object)__instance.hauntingPlayer != (Object)null)
			{
				EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.SleepDialysisDemon, __instance.hauntingPlayer.playerUsername);
			}
		}
	}
	[HarmonyPatch(typeof(EntranceTeleport), "TeleportPlayer")]
	internal class EntranceTeleportPatch
	{
		[HarmonyPostfix]
		private static void Postfix(EntranceTeleport __instance)
		{
			int num = 1;
			if (__instance.isEntranceToBuilding && RoundManager.Instance.currentDungeonType == num)
			{
				EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.SixThirtyTustinAvenue, HelperTools.LocalPlayerController.playerUsername);
			}
		}
	}
	[HarmonyPatch(typeof(GiantKiwiAI), "FinishPryOpenDoor")]
	internal class GiantKiwiAIPatch
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.BirdIsTheWord, HelperTools.LocalPlayerController.playerUsername, serverUnlock: true);
		}
	}
	[HarmonyPatch(typeof(GrabbableObject), "GrabItem")]
	internal class GrabbableObjectGrabItemPatch
	{
		[HarmonyPostfix]
		private static void Postfix(GrabbableObject __instance)
		{
			if (105f * __instance.playerHeldBy.carryWeight - 105f > 100f)
			{
				EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.CheddahLaden, __instance.playerHeldBy.playerUsername);
			}
		}
	}
	[HarmonyPatch(typeof(GrabbableObject), "OnBroughtToShip")]
	internal class GrabbableObjectBroughtToShipPatch
	{
		private static readonly string cashRegisterItemName = "Cash register";

		private static readonly string eggItemName = "Egg";

		private static readonly string giftBoxItemName = "Gift Box";

		[HarmonyPostfix]
		private static void Postfix(GrabbableObject __instance)
		{
			if ((Object)(object)__instance.playerHeldBy != (Object)null)
			{
				if (__instance.itemProperties.itemName == cashRegisterItemName)
				{
					EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.JiggleJiggle, __instance.playerHeldBy.playerUsername);
				}
				else if (__instance.itemProperties.itemName == eggItemName)
				{
					EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.Scrambled, __instance.playerHeldBy.playerUsername);
				}
				else if (__instance.itemProperties.itemName == giftBoxItemName)
				{
					EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.XmasInHarlem, __instance.playerHeldBy.playerUsername);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Terminal), "RunTerminalEvents")]
	internal class InfiniteCreditsPatch
	{
		[HarmonyPostfix]
		private static void Postfix(ref int ___groupCredits)
		{
			___groupCredits = 69420;
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB), "KillPlayer")]
	internal class CauseOfDeathPatch
	{
		[HarmonyPostfix]
		private static void Postfix(CauseOfDeath causeOfDeath, PlayerControllerB __instance)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Invalid comparison between Unknown and I4
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Invalid comparison between Unknown and I4
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Invalid comparison between Unknown and I4
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Invalid comparison between Unknown and I4
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Invalid comparison between Unknown and I4
			string playerUsername = __instance.playerUsername;
			if ((int)causeOfDeath == 1)
			{
				EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.ItIsWhatItIs, playerUsername);
			}
			else if ((int)causeOfDeath == 2)
			{
				EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.FallGuy, playerUsername);
			}
			else if ((int)causeOfDeath == 16)
			{
				EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.GenerationalCrashout, playerUsername);
			}
			else if ((int)causeOfDeath == 3)
			{
				EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.Firework, playerUsername);
			}
			else if ((int)causeOfDeath == 13)
			{
				EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.HotToGo, playerUsername);
			}
			else if ((int)causeOfDeath == 10)
			{
				EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.SeeYaLater, playerUsername);
			}
		}
	}
	[HarmonyPatch(typeof(MouthDogAI), "KillPlayer")]
	internal class MouthDogAIPatch
	{
		[HarmonyPostfix]
		private static void Postfix(int playerId)
		{
			PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[playerId];
			if ((Object)(object)val != (Object)null)
			{
				EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.ShouldNotHaveSaidThat, val.playerUsername);
			}
		}
	}
	[HarmonyPatch(typeof(Terminal), "ParsePlayerSentence")]
	internal class TerminalPatch
	{
		private static readonly int inverseTpUnlockableID = 19;

		private static readonly int purpleSuitUnlockableID = 24;

		[HarmonyPostfix]
		private static void Postfix(ref TerminalNode __result, Terminal __instance)
		{
			if (__instance.screenText.text.Length <= 0)
			{
				return;
			}
			string text = __instance.screenText.text.Substring(__instance.screenText.text.Length - __instance.textAdded).ToLower();
			if (text.Split(new char[1] { ' ' }).Length != 0 && "confirm".StartsWith(text))
			{
				string playerUsername = GetPlayerUsingTerminal()?.playerUsername;
				if (__result.shipUnlockableID == inverseTpUnlockableID)
				{
					EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.DominoEffect, playerUsername, serverUnlock: true);
				}
				else if (__result.shipUnlockableID == purpleSuitUnlockableID)
				{
					EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.LookinGood, playerUsername, serverUnlock: true);
				}
				else if (__result.buyRerouteToMoon != -1 && __result.buyRerouteToMoon != -2 && __result.itemCost > 0 && StartOfRound.Instance.inShipPhase && !StartOfRound.Instance.travellingToNewLevel)
				{
					EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.SpaceIsTheBest, playerUsername);
				}
			}
		}

		public static PlayerControllerB GetPlayerUsingTerminal()
		{
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (val.inTerminalMenu)
				{
					return val;
				}
			}
			return null;
		}
	}
	[HarmonyPatch(typeof(VehicleController), "SetIgnition")]
	internal class VehicleControllerPatch
	{
		[HarmonyPostfix]
		private static void Postfix(VehicleController __instance)
		{
			if ((Object)(object)__instance.currentDriver != (Object)null)
			{
				EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.NewWheels, __instance.currentDriver.playerUsername);
			}
			if ((Object)(object)__instance.currentPassenger != (Object)null)
			{
				EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.NewWheels, __instance.currentPassenger.playerUsername);
			}
		}
	}
}