using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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 LocalHudControl
{
	[BepInPlugin("local.howtofish.hudcontrol", "HUD Control", "1.0.0")]
	[DefaultExecutionOrder(30000)]
	public sealed class HudControl : BaseUnityPlugin
	{
		public const string Id = "local.howtofish.hudcontrol";

		public static HudControl Instance;

		private static readonly FieldInfo UiInstance = AccessTools.Field(typeof(PlayerUI), "_instance");

		private static readonly string[] GroupNames = new string[3] { "_mainCanvas", "_fxCanvas", "_bossCanvas" };

		private readonly List<HudGroup> groups = new List<HudGroup>();

		private ConfigEntry<float> scaleSetting;

		private ConfigEntry<float> opacitySetting;

		private ConfigEntry<bool> hideSetting;

		private Harmony harmony;

		private PlayerUI boundUi;

		private bool open;

		private bool dirty;

		private float nextScan;

		private float saveAt;

		private Rect window = new Rect(32f, 80f, 400f, 300f);

		private CursorLockMode oldLock;

		private bool oldVisible;

		private GUIStyle heading;

		private GUIStyle label;

		private GUIStyle button;

		private GUIStyle checkbox;

		public static bool IsOpen
		{
			get
			{
				if ((Object)(object)Instance != (Object)null)
				{
					return Instance.open;
				}
				return false;
			}
		}

		private void Awake()
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Expected O, but got Unknown
			Instance = this;
			((BaseUnityPlugin)this).Config.SaveOnConfigSet = false;
			scaleSetting = ((BaseUnityPlugin)this).Config.Bind<float>("HUD", "Scale", 1f, new ConfigDescription("Base HUD scale: 0.5 (50%) to 1 (default).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 1f), Array.Empty<object>()));
			opacitySetting = ((BaseUnityPlugin)this).Config.Bind<float>("HUD", "Opacity", 1f, new ConfigDescription("Base HUD opacity: 0 (transparent) to 1 (opaque).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			hideSetting = ((BaseUnityPlugin)this).Config.Bind<bool>("HUD", "HideHUD", false, "Hide the base HUD. The F1 settings panel remains accessible.");
			scaleSetting.Value = HudValues.Clamp(scaleSetting.Value, 0.5f, 1f, 1f);
			opacitySetting.Value = HudValues.Clamp(opacitySetting.Value, 0f, 1f, 1f);
			harmony = new Harmony("local.howtofish.hudcontrol");
			harmony.PatchAll(typeof(HudControl).Assembly);
			((BaseUnityPlugin)this).Config.Save();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"HUD Control loaded. F1 opens scale, visibility and opacity settings.");
		}

		private void Update()
		{
			Keyboard current = Keyboard.current;
			if (current != null && ((ButtonControl)current.f1Key).wasPressedThisFrame)
			{
				SetOpen(!open);
			}
			if (Time.unscaledTime >= nextScan)
			{
				nextScan = Time.unscaledTime + 0.5f;
				object? value = UiInstance.GetValue(null);
				PlayerUI val = (PlayerUI)((value is PlayerUI) ? value : null);
				if ((Object)(object)val != (Object)(object)boundUi || ((Object)(object)val != (Object)null && groups.Count == 0) || ((Object)(object)val == (Object)null && groups.Count > 0))
				{
					Bind(val);
				}
			}
		}

		private void Bind(PlayerUI ui)
		{
			foreach (HudGroup group in groups)
			{
				group.Restore();
			}
			groups.Clear();
			boundUi = ui;
			if ((Object)(object)ui == (Object)null)
			{
				return;
			}
			List<CanvasGroup> list = new List<CanvasGroup>();
			string[] groupNames = GroupNames;
			foreach (string text in groupNames)
			{
				object? value = AccessTools.Field(typeof(PlayerUI), text).GetValue(ui);
				CanvasGroup val = (CanvasGroup)((value is CanvasGroup) ? value : null);
				if ((Object)(object)val != (Object)null && !list.Contains(val))
				{
					list.Add(val);
				}
			}
			foreach (CanvasGroup item in list)
			{
				bool flag = false;
				foreach (CanvasGroup item2 in list)
				{
					if ((Object)(object)item2 != (Object)(object)item && ((Component)item).transform.IsChildOf(((Component)item2).transform))
					{
						flag = true;
					}
				}
				if (!flag)
				{
					groups.Add(new HudGroup(item));
					((BaseUnityPlugin)this).Logger.LogInfo((object)("Controlling base HUD group: " + ((Object)item).name));
				}
			}
		}

		private void LateUpdate()
		{
			foreach (HudGroup group in groups)
			{
				group.Apply(scaleSetting.Value, hideSetting.Value ? 0f : opacitySetting.Value);
			}
			if (open)
			{
				Cursor.lockState = (CursorLockMode)0;
				Cursor.visible = true;
			}
			if (dirty && Time.unscaledTime >= saveAt)
			{
				Save();
			}
		}

		public void CaptureGameAlpha(MethodBase method)
		{
			string text = ((method.Name == "ToggleMainCanvas") ? "_mainCanvas" : ((method.Name == "ToggleFXCanvas") ? "_fxCanvas" : "_bossCanvas"));
			object? value = UiInstance.GetValue(null);
			PlayerUI val = (PlayerUI)((value is PlayerUI) ? value : null);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			object? value2 = AccessTools.Field(typeof(PlayerUI), text).GetValue(val);
			CanvasGroup val2 = (CanvasGroup)((value2 is CanvasGroup) ? value2 : null);
			foreach (HudGroup group in groups)
			{
				if ((Object)(object)group.Group == (Object)(object)val2)
				{
					group.CaptureAlpha();
				}
			}
		}

		public void CaptureCanvasScale(CanvasScaler scaler, float value)
		{
			foreach (HudGroup group in groups)
			{
				group.CaptureCanvasScale(scaler, value);
			}
		}

		public void SetOpen(bool value)
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Invalid comparison between Unknown and I4
			if (open == value)
			{
				return;
			}
			if (value)
			{
				oldLock = Cursor.lockState;
				oldVisible = Cursor.visible;
				open = true;
				try
				{
					PlayerCamera.ToggleMouse(true);
				}
				catch
				{
				}
				Cursor.lockState = (CursorLockMode)0;
				Cursor.visible = true;
			}
			else
			{
				open = false;
				try
				{
					PlayerCamera.ToggleMouse((int)oldLock != 1);
				}
				catch
				{
					Cursor.lockState = oldLock;
					Cursor.visible = oldVisible;
				}
				Save();
			}
		}

		private void Changed()
		{
			dirty = true;
			saveAt = Time.unscaledTime + 0.4f;
		}

		private void Save()
		{
			if (dirty)
			{
				((BaseUnityPlugin)this).Config.Save();
				dirty = false;
			}
		}

		private void OnGUI()
		{
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Expected O, but got Unknown
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: 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_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			if (open)
			{
				if (heading == null)
				{
					heading = new GUIStyle(GUI.skin.label)
					{
						fontSize = 21,
						fontStyle = (FontStyle)1
					};
					label = new GUIStyle(GUI.skin.label)
					{
						fontSize = 15
					};
					button = new GUIStyle(GUI.skin.button)
					{
						fontSize = 14
					};
					checkbox = new GUIStyle(GUI.skin.toggle)
					{
						fontSize = 16
					};
				}
				GUI.depth = -10000;
				((Rect)(ref window)).width = Mathf.Min(400, Screen.width);
				((Rect)(ref window)).height = Mathf.Min(300, Screen.height);
				((Rect)(ref window)).x = Mathf.Clamp(((Rect)(ref window)).x, 0f, Mathf.Max(0f, (float)Screen.width - ((Rect)(ref window)).width));
				((Rect)(ref window)).y = Mathf.Clamp(((Rect)(ref window)).y, 0f, Mathf.Max(0f, (float)Screen.height - ((Rect)(ref window)).height));
				window = GUI.Window(4740420, window, new WindowFunction(DrawWindow), "");
			}
		}

		private void DrawWindow(int id)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: 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_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0353: Unknown result type (might be due to invalid IL or missing references)
			GUI.Label(new Rect(18f, 12f, 290f, 32f), "HUD settings", heading);
			if (GUI.Button(new Rect(((Rect)(ref window)).width - 45f, 12f, 28f, 27f), "X", button))
			{
				SetOpen(value: false);
			}
			GUI.Label(new Rect(18f, 51f, ((Rect)(ref window)).width - 36f, 24f), "Scale                         " + Mathf.RoundToInt(scaleSetting.Value * 100f) + "%", label);
			float num = Mathf.Round(GUI.HorizontalSlider(new Rect(20f, 81f, ((Rect)(ref window)).width - 40f, 22f), scaleSetting.Value, 0.5f, 1f) * 100f) / 100f;
			GUI.Label(new Rect(18f, 101f, ((Rect)(ref window)).width - 36f, 23f), "50%                                                 100% (default)", label);
			bool flag = GUI.Toggle(new Rect(20f, 133f, ((Rect)(ref window)).width - 40f, 26f), hideSetting.Value, " Hide HUD", checkbox);
			GUI.Label(new Rect(18f, 171f, ((Rect)(ref window)).width - 36f, 24f), "Opacity                      " + Mathf.RoundToInt(opacitySetting.Value * 100f) + "%", label);
			float num2 = Mathf.Round(GUI.HorizontalSlider(new Rect(20f, 202f, ((Rect)(ref window)).width - 40f, 22f), opacitySetting.Value, 0f, 1f) * 100f) / 100f;
			if (num != scaleSetting.Value || num2 != opacitySetting.Value || flag != hideSetting.Value)
			{
				scaleSetting.Value = num;
				opacitySetting.Value = num2;
				hideSetting.Value = flag;
				Changed();
			}
			if (GUI.Button(new Rect(18f, 246f, 128f, 30f), "Reset defaults", button))
			{
				ConfigEntry<float> obj = scaleSetting;
				float value = (opacitySetting.Value = 1f);
				obj.Value = value;
				hideSetting.Value = false;
				Changed();
			}
			GUI.Label(new Rect(163f, 249f, ((Rect)(ref window)).width - 170f, 25f), (groups.Count == 0) ? "Load a game to preview" : "F1 / Esc to close", label);
			GUI.DragWindow(new Rect(0f, 0f, ((Rect)(ref window)).width - 52f, 45f));
		}

		private void OnDestroy()
		{
			SetOpen(value: false);
			Save();
			foreach (HudGroup group in groups)
			{
				group.Restore();
			}
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			Instance = null;
		}
	}
	public sealed class HudGroup
	{
		private readonly RectTransform rect;

		private readonly Canvas rootCanvas;

		private readonly Vector3 originalScale;

		private readonly Vector2 originalSize;

		private readonly bool originalRaycasts;

		private readonly bool originalInteractable;

		private readonly MultiplierState alpha;

		private readonly MultiplierState canvasScale;

		public CanvasGroup Group { get; private set; }

		public HudGroup(CanvasGroup group)
		{
			//IL_0025: 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_0036: 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)
			Group = group;
			ref RectTransform reference = ref rect;
			Transform transform = ((Component)group).transform;
			reference = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			originalScale = ((Transform)rect).localScale;
			originalSize = rect.sizeDelta;
			originalRaycasts = group.blocksRaycasts;
			originalInteractable = group.interactable;
			alpha = new MultiplierState(group.alpha);
			Canvas component = ((Component)group).GetComponent<Canvas>();
			if ((Object)(object)component != (Object)null && component.isRootCanvas)
			{
				rootCanvas = component;
				canvasScale = new MultiplierState(component.scaleFactor);
			}
		}

		public void CaptureAlpha()
		{
			if ((Object)(object)Group != (Object)null)
			{
				alpha.SetBaseline(Group.alpha);
			}
		}

		public void CaptureCanvasScale(CanvasScaler scaler, float value)
		{
			if ((Object)(object)rootCanvas != (Object)null && (Object)(object)((Component)scaler).gameObject == (Object)(object)((Component)rootCanvas).gameObject)
			{
				canvasScale.SetBaseline(value);
			}
		}

		public void Apply(float scale, float opacity)
		{
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: 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_00e1: 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_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: 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_013e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Group == (Object)null)
			{
				return;
			}
			alpha.Observe(Group.alpha);
			Group.alpha = alpha.Apply(opacity);
			Group.blocksRaycasts = opacity > 0f && originalRaycasts;
			Group.interactable = opacity > 0f && originalInteractable;
			if ((Object)(object)rootCanvas != (Object)null)
			{
				canvasScale.Observe(rootCanvas.scaleFactor);
				rootCanvas.scaleFactor = canvasScale.Apply(scale);
			}
			else if ((Object)(object)rect != (Object)null)
			{
				Transform parent = ((Transform)rect).parent;
				RectTransform val = (RectTransform)(object)((parent is RectTransform) ? parent : null);
				if ((Object)(object)val != (Object)null)
				{
					Rect val2 = val.rect;
					Vector2 val3 = Vector2.Scale(((Rect)(ref val2)).size, rect.anchorMax - rect.anchorMin);
					rect.sizeDelta = new Vector2(HudValues.CompensatedSize(val3.x, originalSize.x, scale), HudValues.CompensatedSize(val3.y, originalSize.y, scale));
				}
				((Transform)rect).localScale = originalScale * scale;
			}
		}

		public void Restore()
		{
			//IL_0081: 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)
			if (!((Object)(object)Group == (Object)null))
			{
				Group.alpha = alpha.Baseline;
				Group.blocksRaycasts = originalRaycasts;
				Group.interactable = originalInteractable;
				if ((Object)(object)rootCanvas != (Object)null)
				{
					rootCanvas.scaleFactor = canvasScale.Baseline;
				}
				else if ((Object)(object)rect != (Object)null)
				{
					((Transform)rect).localScale = originalScale;
					rect.sizeDelta = originalSize;
				}
			}
		}
	}
	[HarmonyPatch(typeof(Player), "get_BlockInputs")]
	internal static class BlockPlayerInput
	{
		private static void Postfix(Player __instance, ref bool __result)
		{
			if (HudControl.IsOpen && (Object)(object)__instance == (Object)(object)Player.LocalPlayer)
			{
				__result = true;
			}
		}
	}
	[HarmonyPatch]
	internal static class BlockCameraInput
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			string[] array = new string[4] { "MouseClick", "MouseInput", "ControllerRotation", "ApplyAimAssist" };
			foreach (string text in array)
			{
				yield return AccessTools.Method(typeof(PlayerCamera), text, (Type[])null, (Type[])null);
			}
		}

		private static bool Prefix()
		{
			return !HudControl.IsOpen;
		}
	}
	[HarmonyPatch(typeof(PauseManager), "PauseInput")]
	internal static class CloseOnEscape
	{
		private static bool Prefix(CallbackContext context)
		{
			if (!HudControl.IsOpen)
			{
				return true;
			}
			if (((CallbackContext)(ref context)).performed)
			{
				HudControl.Instance.SetOpen(value: false);
			}
			return false;
		}
	}
	[HarmonyPatch]
	internal static class RespectGameVisibility
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			string[] array = new string[3] { "ToggleMainCanvas", "ToggleFXCanvas", "ToggleBossCanvas" };
			foreach (string text in array)
			{
				yield return AccessTools.Method(typeof(PlayerUI), text, (Type[])null, (Type[])null);
			}
		}

		private static void Postfix(MethodBase __originalMethod)
		{
			if ((Object)(object)HudControl.Instance != (Object)null)
			{
				HudControl.Instance.CaptureGameAlpha(__originalMethod);
			}
		}
	}
	[HarmonyPatch(typeof(CanvasScaler), "SetScaleFactor")]
	internal static class RespectResolutionScale
	{
		private static void Postfix(CanvasScaler __instance, float __0)
		{
			if ((Object)(object)HudControl.Instance != (Object)null)
			{
				HudControl.Instance.CaptureCanvasScale(__instance, __0);
			}
		}
	}
	public static class HudValues
	{
		public static float Clamp(float value, float minimum, float maximum, float fallback)
		{
			if (float.IsNaN(value) || float.IsInfinity(value))
			{
				return fallback;
			}
			return Math.Max(minimum, Math.Min(maximum, value));
		}

		public static float CompensatedSize(float parentSpan, float originalDelta, float scale)
		{
			return (parentSpan + originalDelta) / scale - parentSpan;
		}
	}
	public sealed class MultiplierState
	{
		private float applied;

		private bool hasApplied;

		public float Baseline { get; private set; }

		public MultiplierState(float initial)
		{
			Baseline = initial;
		}

		public void Observe(float current)
		{
			if (!hasApplied || Math.Abs(current - applied) > 1E-05f)
			{
				Baseline = current;
			}
		}

		public void SetBaseline(float value)
		{
			Baseline = value;
		}

		public float Apply(float multiplier)
		{
			hasApplied = true;
			return applied = Baseline * multiplier;
		}
	}
}