using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using EggChat.Patches;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
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: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("EggChat")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("(WIP) Quality-of-life additions to text chat.")]
[assembly: AssemblyFileVersion("0.3.2.0")]
[assembly: AssemblyInformationalVersion("0.3.2")]
[assembly: AssemblyProduct("EggChat")]
[assembly: AssemblyTitle("EggChat")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.3.2.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace EggChat
{
	[BepInPlugin("EggChat", "EggChat", "0.3.2")]
	public class Plugin : BaseUnityPlugin
	{
		public static Plugin Instance;

		public static int maxCharLimit = 127;

		private static ConfigEntry<int> chatBgOpacity;

		private static ConfigEntry<bool> wideChat;

		private void Awake()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Initializing EggChat");
			SetUpConfigs();
			Instance = this;
			Harmony val = new Harmony("EggChat");
			val.PatchAll();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Initialized EggChat");
		}

		public static bool isLocalPlayerDead()
		{
			return GameNetworkManager.Instance.localPlayerController.isPlayerDead;
		}

		private void SetUpConfigs()
		{
			chatBgOpacity = ((BaseUnityPlugin)this).Config.Bind<int>("UI", "Chat Background Opacity", 0, "The opacity of the chat background. Set values 0-100.");
			HUDManagerPatch.chatBgOpacity = chatBgOpacity.Value;
			chatBgOpacity.SettingChanged += delegate
			{
				HUDManagerPatch.chatBgOpacity = chatBgOpacity.Value;
				HUDManagerPatch.SetBgOpacity();
			};
			wideChat = ((BaseUnityPlugin)this).Config.Bind<bool>("UI", "Wide Chat", false, "Make the chat wider.");
			HUDManagerPatch.wideChat = wideChat.Value;
			wideChat.SettingChanged += delegate
			{
				HUDManagerPatch.wideChat = wideChat.Value;
				HUDManagerPatch.SetWidthType();
			};
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "EggChat";

		public const string PLUGIN_NAME = "EggChat";

		public const string PLUGIN_VERSION = "0.3.2";
	}
}
namespace EggChat.Patches
{
	[HarmonyPatch(typeof(HUDManager))]
	internal class HUDManagerPatch
	{
		public class Attributes
		{
			public class Text
			{
				public class Default
				{
					public static float anchorMinX;

					public static float anchorMaxX = DefaultAnchorMaxX;

					public static float sizeDeltaX;
				}

				public class Wide
				{
					public static float anchorMinX = 0.6f;

					public static float anchorMaxX = WideAnchorMaxX;

					public static float sizeDeltaX = WideSizeDeltaX;
				}
			}

			public class Input
			{
				public class Default
				{
					public static float anchorMinX;

					public static float anchorMaxX = DefaultAnchorMaxX;

					public static float sizeDeltaX;
				}

				public class Wide
				{
					public static float anchorMinX = 0.4f;

					public static float anchorMaxX = WideAnchorMaxX;

					public static float sizeDeltaX = WideSizeDeltaX;
				}
			}

			public class Image
			{
				public class Default
				{
					public static float anchorMinX;

					public static float sizeDeltaX = WideSizeDeltaX;
				}

				public class Wide
				{
					public static float anchorMinX = 1f;

					public static float sizeDeltaX = WideSizeDeltaX + 100f;
				}
			}

			public class Background
			{
				public class Default
				{
					public static float anchorMaxX = DefaultAnchorMaxX;

					public static float sizeDeltaX = DefaultSizeDeltaX;
				}

				public class Wide
				{
					public static float anchorMaxX = WideAnchorMaxX;

					public static float sizeDeltaX = WideSizeDeltaX;
				}
			}

			public static float DefaultSizeDeltaX;

			private static readonly float DefaultAnchorMaxX = 0.5f;

			private static readonly float WideAnchorMaxX = 1f;

			private static readonly float WideSizeDeltaX = 141f;
		}

		internal static int chatBgOpacity;

		internal static bool wideChat;

		private static Transform bottomLeftCorner;

		private static Transform input;

		private static Transform text;

		private static Transform image;

		private static GameObject background;

		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void HUDManager_awake(HUDManager __instance)
		{
			__instance.chatTextField.characterLimit = Plugin.maxCharLimit - 1;
			bottomLeftCorner = __instance.HUDContainer.transform.Find("BottomLeftCorner");
			text = bottomLeftCorner.Find("ChatText");
			input = bottomLeftCorner.Find("InputField (TMP)");
			image = bottomLeftCorner.Find("Image");
			SetDefaultAttributes();
			AddChatBg();
			SetBgOpacity();
			if (wideChat)
			{
				SetWidthType();
			}
		}

		private static void AddChatBg()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)background))
			{
				background = new GameObject("ChatBG");
				Transform transform = background.transform;
				transform.SetParent(bottomLeftCorner);
				transform.SetSiblingIndex(0);
				transform.SetPositionAndRotation(image.position, image.rotation);
				transform.localScale = image.localScale;
				RectTransform t = background.AddComponent<RectTransform>();
				CopyAttributes(t, ((Component)image).GetComponent<RectTransform>());
				CanvasGroup val = background.AddComponent<CanvasGroup>();
				val.alpha = (float)chatBgOpacity / 100f;
				val.ignoreParentGroups = true;
				Sprite sprite = Sprite.Create(Texture2D.whiteTexture, new Rect(0f, 0f, 4f, 4f), new Vector2(0f, 0f));
				Image val2 = background.AddComponent<Image>();
				val2.sprite = sprite;
				((Graphic)val2).color = Color.black;
			}
		}

		private static void SetDefaultAttributes()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			Attributes.DefaultSizeDeltaX = ((Component)image).GetComponent<RectTransform>().sizeDelta.x;
			Attributes.Text.Default.anchorMinX = ((Component)text).GetComponent<RectTransform>().anchorMin.x;
			Attributes.Text.Default.sizeDeltaX = ((Component)text).GetComponent<RectTransform>().sizeDelta.x;
			Attributes.Input.Default.anchorMinX = ((Component)input).GetComponent<RectTransform>().anchorMin.x;
			Attributes.Input.Default.sizeDeltaX = ((Component)input).GetComponent<RectTransform>().sizeDelta.x;
			Attributes.Image.Default.anchorMinX = ((Component)input).GetComponent<RectTransform>().anchorMin.x;
		}

		public static void SetBgOpacity()
		{
			CanvasGroup component = background.GetComponent<CanvasGroup>();
			component.alpha = (float)chatBgOpacity / 100f;
		}

		private static void SetWidthAttributes(RectTransform rt, float? anchorMin, float? anchorMax, float sizeDelta)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			if (anchorMin.HasValue)
			{
				rt.anchorMin = new Vector2(anchorMin.Value, rt.anchorMin.y);
			}
			if (anchorMax.HasValue)
			{
				rt.anchorMax = new Vector2(anchorMax.Value, rt.anchorMax.y);
			}
			rt.sizeDelta = new Vector2(sizeDelta, rt.sizeDelta.y);
		}

		public static void SetWidthType()
		{
			if (wideChat)
			{
				SetWidthAttributes(((Component)input).GetComponent<RectTransform>(), Attributes.Input.Wide.anchorMinX, Attributes.Input.Wide.anchorMaxX, Attributes.Input.Wide.sizeDeltaX);
				SetWidthAttributes(((Component)text).GetComponent<RectTransform>(), Attributes.Text.Wide.anchorMinX, Attributes.Text.Wide.anchorMaxX, Attributes.Text.Wide.sizeDeltaX);
				SetWidthAttributes(((Component)image).GetComponent<RectTransform>(), Attributes.Image.Wide.anchorMinX, null, Attributes.Image.Wide.sizeDeltaX);
				SetWidthAttributes(background.GetComponent<RectTransform>(), null, Attributes.Background.Wide.anchorMaxX, Attributes.Background.Wide.sizeDeltaX);
			}
			else
			{
				SetWidthAttributes(((Component)input).GetComponent<RectTransform>(), Attributes.Input.Default.anchorMinX, Attributes.Input.Default.anchorMaxX, Attributes.Input.Default.sizeDeltaX);
				SetWidthAttributes(((Component)text).GetComponent<RectTransform>(), Attributes.Text.Default.anchorMinX, Attributes.Text.Default.anchorMaxX, Attributes.Text.Default.sizeDeltaX);
				SetWidthAttributes(((Component)image).GetComponent<RectTransform>(), Attributes.Image.Default.anchorMinX, null, Attributes.Image.Default.sizeDeltaX);
				SetWidthAttributes(background.GetComponent<RectTransform>(), null, Attributes.Background.Default.anchorMaxX, Attributes.Background.Default.sizeDeltaX);
			}
		}

		private static void CopyAttributes(RectTransform t1, RectTransform t2)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			t1.anchoredPosition = t2.anchoredPosition;
			t1.anchoredPosition3D = t2.anchoredPosition3D;
			t1.offsetMax = t2.offsetMax;
			t1.offsetMin = t2.offsetMin;
			((Transform)t1).eulerAngles = ((Transform)t2).eulerAngles;
			((Transform)t1).forward = ((Transform)t2).forward;
		}

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void HUDManager_update(HUDManager __instance)
		{
			if (GameNetworkManager.Instance.localPlayerController.isPlayerDead)
			{
				__instance.Inventory.canvasGroup.alpha = 0f;
				__instance.PlayerInfo.canvasGroup.alpha = 0f;
				__instance.Clock.canvasGroup.alpha = 0f;
			}
		}

		[HarmonyPatch("EnableChat_performed")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> EnableChat_performed_transpiler(IEnumerable<CodeInstruction> instructions)
		{
			FieldInfo isPlayerDead = typeof(PlayerControllerB).GetField("isPlayerDead");
			bool referenceToIsPlayerDead = false;
			foreach (CodeInstruction instruction in instructions)
			{
				if (CodeInstructionExtensions.LoadsField(instruction, isPlayerDead, false))
				{
					referenceToIsPlayerDead = true;
				}
				if (referenceToIsPlayerDead && instruction.opcode == OpCodes.Ret)
				{
					referenceToIsPlayerDead = false;
					yield return new CodeInstruction(OpCodes.Nop, (object)null);
				}
				else
				{
					yield return instruction;
				}
			}
		}

		[HarmonyPatch("SubmitChat_performed")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> SubmitChat_performed_transpiler(IEnumerable<CodeInstruction> instructions)
		{
			FieldInfo isPlayerDead = typeof(PlayerControllerB).GetField("isPlayerDead");
			bool referenceToIsPlayerDead = false;
			foreach (CodeInstruction instruction in instructions)
			{
				if (CodeInstructionExtensions.LoadsField(instruction, isPlayerDead, false))
				{
					referenceToIsPlayerDead = true;
				}
				if (referenceToIsPlayerDead && instruction.opcode == OpCodes.Ret)
				{
					referenceToIsPlayerDead = false;
					yield return new CodeInstruction(OpCodes.Nop, (object)null);
				}
				else if (instruction.opcode == OpCodes.Ldc_I4_S && (sbyte)instruction.operand == 50)
				{
					yield return new CodeInstruction(OpCodes.Ldc_I4_S, (object)Plugin.maxCharLimit);
				}
				else
				{
					yield return instruction;
				}
			}
		}

		[HarmonyPatch("AddPlayerChatMessageServerRpc")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> AddPlayerChatMessageServerRpc_transpiler(IEnumerable<CodeInstruction> instructions)
		{
			foreach (CodeInstruction instruction in instructions)
			{
				if (instruction.opcode == OpCodes.Ldc_I4_S && (sbyte)instruction.operand == 50)
				{
					yield return new CodeInstruction(OpCodes.Ldc_I4_S, (object)Plugin.maxCharLimit);
				}
				else
				{
					yield return instruction;
				}
			}
		}

		[HarmonyPatch("AddPlayerChatMessageClientRpc")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> AddPlayerChatMessageClientRpc_transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator iL)
		{
			FieldInfo isPlayerDead = typeof(PlayerControllerB).GetField("isPlayerDead");
			bool referenceToIsPlayerDead = false;
			Label addChatMessageLabel = default(Label);
			foreach (CodeInstruction instruction2 in instructions)
			{
				if (instruction2.opcode == OpCodes.Brtrue)
				{
					addChatMessageLabel = (Label)instruction2.operand;
				}
			}
			foreach (CodeInstruction instruction in instructions)
			{
				if (CodeInstructionExtensions.LoadsField(instruction, isPlayerDead, false))
				{
					referenceToIsPlayerDead = true;
				}
				if (referenceToIsPlayerDead && instruction.opcode == OpCodes.Ret)
				{
					referenceToIsPlayerDead = false;
					yield return new CodeInstruction(OpCodes.Call, (object)typeof(Plugin).GetMethod("isLocalPlayerDead"));
					yield return new CodeInstruction(OpCodes.Brtrue, (object)addChatMessageLabel);
					yield return instruction;
				}
				else
				{
					yield return instruction;
				}
			}
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB))]
	internal class PlayerControllerBPatch
	{
		[HarmonyPatch("KillPlayer")]
		[HarmonyPostfix]
		private static void KillPlayer_postfix()
		{
			HUDManager.Instance.HideHUD(false);
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	internal class StartOfRoundPatch
	{
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> EndOfGame_transpiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo hideHUD = typeof(HUDManager).GetMethod("HideHUD");
			foreach (CodeInstruction instruction in instructions)
			{
				if (CodeInstructionExtensions.Calls(instruction, hideHUD))
				{
					yield return new CodeInstruction(OpCodes.Pop, (object)null);
					yield return new CodeInstruction(OpCodes.Ldc_I4_0, (object)null);
					yield return instruction;
				}
				else
				{
					yield return instruction;
				}
			}
		}
	}
}