using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using TMPro;
using UnityEngine;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("pixx; TactiKot")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Numerical stamina and affliction values for current PEAK builds.")]
[assembly: AssemblyFileVersion("1.1.0.0")]
[assembly: AssemblyInformationalVersion("1.1.0")]
[assembly: AssemblyProduct("StaminaStatsTactikot")]
[assembly: AssemblyTitle("StaminaStatsTactikot")]
[assembly: AssemblyVersion("1.1.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 StaminaStatsTactikot
{
	internal sealed class AfflictionTextTracker : MonoBehaviour
	{
		private BarAffliction affliction;

		private RectTransform textRect;

		private float verticalOffset;

		internal void Initialize(BarAffliction trackedAffliction, float offset)
		{
			affliction = trackedAffliction;
			textRect = ((Component)this).GetComponent<RectTransform>();
			verticalOffset = offset;
		}

		internal void UpdateWidth(float width)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)textRect != (Object)null)
			{
				textRect.sizeDelta = new Vector2(width, textRect.sizeDelta.y);
			}
		}

		internal void UpdateAffliction(BarAffliction updatedAffliction)
		{
			if ((Object)(object)updatedAffliction != (Object)null && (Object)(object)affliction != (Object)(object)updatedAffliction)
			{
				affliction = updatedAffliction;
			}
		}

		private void LateUpdate()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)affliction == (Object)null) && !((Object)(object)textRect == (Object)null))
			{
				RectTransform component = ((Component)affliction).GetComponent<RectTransform>();
				if (!((Object)(object)component == (Object)null))
				{
					Vector3 position = ((Transform)component).position;
					((Transform)textRect).position = new Vector3(position.x, position.y + verticalOffset, ((Transform)textRect).position.z);
				}
			}
		}
	}
	internal static class HudController
	{
		private static readonly Color LowStaminaColor = new Color(1f, 0.3f, 0.3f);

		private static readonly Color MediumStaminaColor = new Color(1f, 0.92f, 0.016f);

		private static readonly Color HighStaminaColor = new Color(0.5f, 1f, 0.5f);

		private static readonly Color ExtraStaminaColor = new Color(1f, 0.92f, 0.016f);

		private static readonly Dictionary<STATUSTYPE, Color> StatusColors = new Dictionary<STATUSTYPE, Color>
		{
			[(STATUSTYPE)0] = new Color(1f, 0.3f, 0.3f),
			[(STATUSTYPE)1] = new Color(0.9f, 0.6f, 0.1f),
			[(STATUSTYPE)2] = new Color(0.2f, 0.6f, 0.9f),
			[(STATUSTYPE)3] = new Color(0.6f, 0.1f, 0.6f),
			[(STATUSTYPE)4] = new Color(0.9f, 0.4f, 0.4f),
			[(STATUSTYPE)5] = new Color(0.5f, 0.1f, 0.5f),
			[(STATUSTYPE)6] = new Color(1f, 0.4f, 0.8f),
			[(STATUSTYPE)7] = new Color(0.6f, 0.4f, 0.2f),
			[(STATUSTYPE)8] = new Color(1f, 0.3f, 0.1f)
		};

		private static readonly Dictionary<STATUSTYPE, TextMeshProUGUI> AfflictionTexts = new Dictionary<STATUSTYPE, TextMeshProUGUI>();

		private static readonly Dictionary<STATUSTYPE, int> RoundedAfflictionValues = new Dictionary<STATUSTYPE, int>();

		private static readonly Dictionary<STATUSTYPE, float> ExactAfflictionValues = new Dictionary<STATUSTYPE, float>();

		private static StaminaBar attachedBar;

		private static GameObject staminaTextContainer;

		private static TextMeshProUGUI staminaText;

		private static TextMeshProUGUI extraStaminaText;

		private static Canvas afflictionCanvas;

		private static TMP_FontAsset gameFont;

		private static Material textMaterial;

		private static int roundedFrame = -1;

		private static int roundedStaminaValue;

		private static int roundedExtraStaminaValue;

		internal static void AttachTo(StaminaBar bar)
		{
			if (!((Object)(object)bar == (Object)null))
			{
				if ((Object)(object)attachedBar != (Object)(object)bar)
				{
					DestroyStaminaText();
					CleanupAfflictionTexts();
					attachedBar = bar;
					InvalidateRoundedValues();
				}
				EnsureStaminaText(bar);
				RefreshAfflictions(bar);
			}
		}

		internal static void UpdateStamina(StaminaBar bar)
		{
			Character observedCharacter = Character.observedCharacter;
			if ((Object)(object)bar == (Object)null || (Object)(object)observedCharacter == (Object)null || (Object)(object)observedCharacter.data == (Object)null)
			{
				SetStaminaTextVisible(visible: false);
				return;
			}
			if ((Object)(object)attachedBar != (Object)(object)bar || (Object)(object)staminaText == (Object)null)
			{
				AttachTo(bar);
			}
			if ((Object)(object)staminaText == (Object)null)
			{
				return;
			}
			float current = observedCharacter.data.currentStamina * 100f;
			float num = observedCharacter.data.extraStamina * 100f;
			float maximum = observedCharacter.GetMaxStamina() * 100f;
			EnsureRoundedValues(bar, observedCharacter);
			ApplyLiveTextSettings(staminaText, Plugin.StaminaFontSize.Value);
			((TMP_Text)staminaText).text = FormatValue(roundedStaminaValue);
			if ((Object)(object)extraStaminaText != (Object)null)
			{
				ApplyLiveTextSettings(extraStaminaText, Plugin.StaminaFontSize.Value);
				bool flag = num > 0.005f;
				((Component)extraStaminaText).gameObject.SetActive(flag);
				if (flag)
				{
					((TMP_Text)extraStaminaText).text = "  +" + FormatValue(roundedExtraStaminaValue);
				}
			}
			UpdateExistingAfflictionTexts();
			UpdateStaminaTextColor(current, maximum, bar);
			bool num2 = (Object)(object)bar.staminaBar != (Object)null && ((Component)bar.staminaBar).gameObject.activeSelf;
			bool flag2 = !observedCharacter.data.fullyPassedOut && !observedCharacter.data.dead;
			SetStaminaTextVisible(num2 && flag2);
		}

		internal static void RefreshAfflictions(StaminaBar bar)
		{
			Character observedCharacter = Character.observedCharacter;
			if ((Object)(object)bar == (Object)null || (Object)(object)observedCharacter == (Object)null || bar.afflictions == null)
			{
				return;
			}
			BarAffliction[] afflictions = bar.afflictions;
			foreach (BarAffliction val in afflictions)
			{
				if ((Object)(object)val != (Object)null)
				{
					UpdateAffliction(val, bar);
				}
			}
		}

		internal static void UpdateAffliction(BarAffliction affliction, StaminaBar bar)
		{
			//IL_003e: 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_006b: 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_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: 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_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			Character observedCharacter = Character.observedCharacter;
			if ((Object)(object)affliction == (Object)null || (Object)(object)bar == (Object)null || (Object)(object)observedCharacter == (Object)null || observedCharacter.refs == null || (Object)(object)observedCharacter.refs.afflictions == (Object)null)
			{
				return;
			}
			STATUSTYPE afflictionType = affliction.afflictionType;
			if (!((Component)affliction).gameObject.activeSelf && !AfflictionTexts.ContainsKey(afflictionType))
			{
				return;
			}
			EnsureRoundedValues(bar, observedCharacter);
			float value;
			float num = (ExactAfflictionValues.TryGetValue(afflictionType, out value) ? value : (observedCharacter.refs.afflictions.GetCurrentStatus(afflictionType) * 100f));
			int value3;
			int value2 = (RoundedAfflictionValues.TryGetValue(afflictionType, out value3) ? value3 : ((int)Math.Round(num, MidpointRounding.AwayFromZero)));
			if (!AfflictionTexts.TryGetValue(afflictionType, out var value4) || (Object)(object)value4 == (Object)null)
			{
				value4 = CreateAfflictionText(affliction);
				AfflictionTexts[afflictionType] = value4;
			}
			else
			{
				ApplyLiveTextSettings(value4, Plugin.AfflictionFontSize.Value);
				AfflictionTextTracker component = ((Component)value4).GetComponent<AfflictionTextTracker>();
				if ((Object)(object)component != (Object)null)
				{
					component.UpdateAffliction(affliction);
					component.UpdateWidth(Mathf.Max(40f, affliction.width * 0.8f));
				}
			}
			((TMP_Text)value4).text = FormatValue(value2);
			((Graphic)value4).color = ResolveStatusColor(afflictionType, affliction);
			((Component)value4).gameObject.SetActive(num > 0.005f);
		}

		internal static void ResetForNewRun()
		{
			CleanupAfflictionTexts();
			DestroyStaminaText();
			attachedBar = null;
			InvalidateRoundedValues();
		}

		internal static void Cleanup()
		{
			CleanupAfflictionTexts();
			DestroyStaminaText();
			if ((Object)(object)afflictionCanvas != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)afflictionCanvas).gameObject);
				afflictionCanvas = null;
			}
			attachedBar = null;
			gameFont = null;
			textMaterial = null;
			InvalidateRoundedValues();
		}

		private static void EnsureStaminaText(StaminaBar bar)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)staminaTextContainer != (Object)null))
			{
				FindGameTextStyle();
				staminaTextContainer = new GameObject("StaminaStatsTactikotContainer");
				staminaTextContainer.transform.SetParent(((Component)bar).transform, false);
				staminaText = CreateText("StaminaText", staminaTextContainer.transform);
				RectTransform rectTransform = ((TMP_Text)staminaText).rectTransform;
				rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
				rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
				rectTransform.pivot = new Vector2(1f, 0f);
				rectTransform.sizeDelta = new Vector2(60f, 30f);
				rectTransform.anchoredPosition = new Vector2(20f, 25f);
				SetupTextStyle(staminaText, Plugin.StaminaFontSize.Value, (TextAlignmentOptions)516);
				extraStaminaText = CreateText("ExtraStaminaText", staminaTextContainer.transform);
				RectTransform rectTransform2 = ((TMP_Text)extraStaminaText).rectTransform;
				rectTransform2.anchorMin = new Vector2(0.5f, 0.5f);
				rectTransform2.anchorMax = new Vector2(0.5f, 0.5f);
				rectTransform2.pivot = new Vector2(0f, 0f);
				rectTransform2.sizeDelta = new Vector2(60f, 30f);
				rectTransform2.anchoredPosition = new Vector2(24f, 25f);
				SetupTextStyle(extraStaminaText, Plugin.StaminaFontSize.Value, (TextAlignmentOptions)513);
				((Graphic)extraStaminaText).color = ExtraStaminaColor;
				if (Plugin.VerboseLogging.Value)
				{
					Plugin.Log.LogInfo((object)"Created stamina text elements.");
				}
			}
		}

		private static TextMeshProUGUI CreateAfflictionText(BarAffliction affliction)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			FindGameTextStyle();
			EnsureAfflictionCanvas();
			TextMeshProUGUI obj = CreateText(((object)Unsafe.As<STATUSTYPE, STATUSTYPE>(ref affliction.afflictionType)/*cast due to .constrained prefix*/).ToString() + "Text", ((Component)afflictionCanvas).transform);
			RectTransform rectTransform = ((TMP_Text)obj).rectTransform;
			rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
			rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
			rectTransform.pivot = new Vector2(0.5f, 0.5f);
			rectTransform.sizeDelta = new Vector2(Mathf.Max(40f, affliction.width * 0.8f), 24f);
			((Component)obj).gameObject.AddComponent<AfflictionTextTracker>().Initialize(affliction, -15f);
			SetupTextStyle(obj, Plugin.AfflictionFontSize.Value, (TextAlignmentOptions)514);
			return obj;
		}

		private static TextMeshProUGUI CreateText(string name, Transform parent)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			TextMeshProUGUI obj = val.AddComponent<TextMeshProUGUI>();
			((Graphic)obj).raycastTarget = false;
			return obj;
		}

		private static void EnsureAfflictionCanvas()
		{
			//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_001e: Expected O, but got Unknown
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)afflictionCanvas != (Object)null))
			{
				GameObject val = new GameObject("StaminaStatsTactikotAfflictionCanvas");
				Object.DontDestroyOnLoad((Object)val);
				val.layer = LayerMask.NameToLayer("UI");
				afflictionCanvas = val.AddComponent<Canvas>();
				afflictionCanvas.renderMode = (RenderMode)0;
				afflictionCanvas.sortingOrder = 100;
				CanvasScaler obj = val.AddComponent<CanvasScaler>();
				obj.uiScaleMode = (ScaleMode)1;
				obj.referenceResolution = new Vector2(1920f, 1080f);
				obj.screenMatchMode = (ScreenMatchMode)0;
				val.AddComponent<GraphicRaycaster>();
			}
		}

		private static void FindGameTextStyle()
		{
			if ((Object)(object)gameFont != (Object)null)
			{
				return;
			}
			TextMeshProUGUI[] array = Resources.FindObjectsOfTypeAll<TextMeshProUGUI>();
			foreach (TextMeshProUGUI val in array)
			{
				bool flag;
				switch (((Object)val).name)
				{
				case "InteractNameText":
				case "InteractPromptText":
				case "ItemPromptMain":
					flag = true;
					break;
				default:
					flag = false;
					break;
				}
				if (flag)
				{
					gameFont = ((TMP_Text)val).font;
					textMaterial = ((Graphic)val).material;
					return;
				}
			}
			TMP_FontAsset[] array2 = Resources.FindObjectsOfTypeAll<TMP_FontAsset>();
			if (array2.Length != 0)
			{
				gameFont = array2[0];
			}
		}

		private static void SetupTextStyle(TextMeshProUGUI text, int fontSize, TextAlignmentOptions alignment)
		{
			//IL_0009: 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_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			((TMP_Text)text).fontSize = fontSize;
			((TMP_Text)text).alignment = alignment;
			((TMP_Text)text).textWrappingMode = (TextWrappingModes)0;
			((TMP_Text)text).overflowMode = (TextOverflowModes)0;
			((Graphic)text).color = Color.white;
			((TMP_Text)text).enableAutoSizing = false;
			((TMP_Text)text).fontStyle = (FontStyles)1;
			((TMP_Text)text).outlineColor = Color32.op_Implicit(Color.black);
			((TMP_Text)text).faceColor = Color32.op_Implicit(Color.white);
			if ((Object)(object)gameFont != (Object)null)
			{
				((TMP_Text)text).font = gameFont;
			}
			if ((Object)(object)textMaterial != (Object)null)
			{
				((Graphic)text).material = textMaterial;
			}
			Shadow obj = ((Component)text).gameObject.AddComponent<Shadow>();
			obj.effectColor = new Color(0f, 0f, 0f, 0.95f);
			obj.effectDistance = new Vector2(2f, -2f);
			ApplyLiveTextSettings(text, fontSize);
		}

		private static void ApplyLiveTextSettings(TextMeshProUGUI text, int fontSize)
		{
			((TMP_Text)text).fontSize = fontSize;
			((TMP_Text)text).outlineWidth = Plugin.TextOutlineThickness.Value;
		}

		private static void UpdateStaminaTextColor(float current, float maximum, StaminaBar bar)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: 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)
			if (!((Object)(object)staminaText == (Object)null))
			{
				float num = ((maximum > 0.001f) ? (current / maximum) : 0f);
				Image val = (((Object)(object)bar.staminaBar != (Object)null) ? ((Component)bar.staminaBar).GetComponent<Image>() : null);
				Color val2;
				if ((Object)(object)val != (Object)null)
				{
					float num2 = default(float);
					float num3 = default(float);
					float num4 = default(float);
					Color.RGBToHSV(((Graphic)val).color, ref num2, ref num3, ref num4);
					val2 = Color.HSVToRGB(num2, Mathf.Clamp01(num3 * 1.2f), Mathf.Clamp01(num4 * 1.3f));
				}
				else
				{
					val2 = ((num < 0.25f) ? LowStaminaColor : ((num < 0.5f) ? MediumStaminaColor : HighStaminaColor));
				}
				float num5 = default(float);
				float num6 = default(float);
				float num7 = default(float);
				Color.RGBToHSV(val2, ref num5, ref num6, ref num7);
				((Graphic)staminaText).color = Color.HSVToRGB(num5, num6, Mathf.Max(0.8f, num7));
				if ((Object)(object)extraStaminaText != (Object)null)
				{
					((Graphic)extraStaminaText).color = ExtraStaminaColor;
				}
			}
		}

		private static Color ResolveStatusColor(STATUSTYPE statusType, BarAffliction affliction)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: 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)
			if (StatusColors.TryGetValue(statusType, out var value))
			{
				return value;
			}
			Image componentInChildren = ((Component)affliction).GetComponentInChildren<Image>();
			if ((Object)(object)componentInChildren == (Object)null)
			{
				return Color.white;
			}
			float num = default(float);
			float num2 = default(float);
			float num3 = default(float);
			Color.RGBToHSV(((Graphic)componentInChildren).color, ref num, ref num2, ref num3);
			return Color.HSVToRGB(num, Mathf.Clamp01(num2 * 1.2f), Mathf.Clamp01(num3 * 1.3f));
		}

		private static void EnsureRoundedValues(StaminaBar bar, Character observed)
		{
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: 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)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			if (roundedFrame == Time.frameCount && (Object)(object)attachedBar == (Object)(object)bar)
			{
				return;
			}
			roundedFrame = Time.frameCount;
			RoundedAfflictionValues.Clear();
			ExactAfflictionValues.Clear();
			List<STATUSTYPE> list = new List<STATUSTYPE>();
			HashSet<STATUSTYPE> hashSet = new HashSet<STATUSTYPE>();
			if (bar.afflictions != null)
			{
				BarAffliction[] afflictions = bar.afflictions;
				foreach (BarAffliction val in afflictions)
				{
					if ((Object)(object)val != (Object)null && hashSet.Add(val.afflictionType))
					{
						list.Add(val.afflictionType);
					}
				}
			}
			List<double> list2 = new List<double>(list.Count + 1) { (double)observed.data.currentStamina * 100.0 };
			foreach (STATUSTYPE item in list)
			{
				float num = ((observed.refs != null && (Object)(object)observed.refs.afflictions != (Object)null) ? (observed.refs.afflictions.GetCurrentStatus(item) * 100f) : 0f);
				ExactAfflictionValues[item] = num;
				list2.Add(num);
			}
			int[] array = MinimaxRounding.Round(list2);
			roundedStaminaValue = array[0];
			for (int j = 0; j < list.Count; j++)
			{
				RoundedAfflictionValues[list[j]] = array[j + 1];
			}
			roundedExtraStaminaValue = (int)Math.Round((double)observed.data.extraStamina * 100.0, MidpointRounding.AwayFromZero);
		}

		private static void UpdateExistingAfflictionTexts()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<STATUSTYPE, TextMeshProUGUI> afflictionText in AfflictionTexts)
			{
				TextMeshProUGUI value = afflictionText.Value;
				if (!((Object)(object)value == (Object)null) && RoundedAfflictionValues.TryGetValue(afflictionText.Key, out var value2))
				{
					ApplyLiveTextSettings(value, Plugin.AfflictionFontSize.Value);
					((TMP_Text)value).text = FormatValue(value2);
					float value3;
					bool flag = ExactAfflictionValues.TryGetValue(afflictionText.Key, out value3) && value3 > 0.005f;
					if (((Component)value).gameObject.activeSelf != flag)
					{
						((Component)value).gameObject.SetActive(flag);
					}
				}
			}
		}

		private static string FormatValue(int value)
		{
			if (!Plugin.ShowPercentageSign.Value)
			{
				return value.ToString();
			}
			return $"{value}%";
		}

		private static void InvalidateRoundedValues()
		{
			roundedFrame = -1;
			roundedStaminaValue = 0;
			roundedExtraStaminaValue = 0;
			RoundedAfflictionValues.Clear();
			ExactAfflictionValues.Clear();
		}

		private static void SetStaminaTextVisible(bool visible)
		{
			if ((Object)(object)staminaTextContainer != (Object)null && staminaTextContainer.activeSelf != visible)
			{
				staminaTextContainer.SetActive(visible);
			}
		}

		private static void DestroyStaminaText()
		{
			if ((Object)(object)staminaTextContainer != (Object)null)
			{
				Object.Destroy((Object)(object)staminaTextContainer);
			}
			staminaTextContainer = null;
			staminaText = null;
			extraStaminaText = null;
		}

		private static void CleanupAfflictionTexts()
		{
			foreach (TextMeshProUGUI value in AfflictionTexts.Values)
			{
				if ((Object)(object)value != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)value).gameObject);
				}
			}
			AfflictionTexts.Clear();
		}
	}
	internal static class MinimaxRounding
	{
		private readonly struct Remainder
		{
			internal int Index { get; }

			internal double Fraction { get; }

			internal Remainder(int index, double fraction)
			{
				Index = index;
				Fraction = fraction;
			}
		}

		internal static int[] Round(IReadOnlyList<double> values)
		{
			if (values == null)
			{
				throw new ArgumentNullException("values");
			}
			int count = values.Count;
			int[] array = new int[count];
			if (count == 0)
			{
				return array;
			}
			double num = 0.0;
			long num2 = 0L;
			List<Remainder> list = new List<Remainder>(count);
			for (int i = 0; i < count; i++)
			{
				double num3 = values[i];
				if (double.IsNaN(num3) || double.IsInfinity(num3))
				{
					throw new ArgumentOutOfRangeException("values", "Values must be finite.");
				}
				double num4 = Math.Floor(num3);
				if (num4 < -2147483648.0 || num4 > 2147483647.0)
				{
					throw new ArgumentOutOfRangeException("values", "Values are outside the supported range.");
				}
				array[i] = (int)num4;
				num2 += array[i];
				num += num3;
				list.Add(new Remainder(i, num3 - num4));
			}
			long num5 = checked((long)Math.Round(num, MidpointRounding.AwayFromZero)) - num2;
			if (num5 < 0 || num5 > count)
			{
				throw new InvalidOperationException("The rounded total cannot be reached.");
			}
			list.Sort(delegate(Remainder left, Remainder right)
			{
				int num7 = right.Fraction.CompareTo(left.Fraction);
				return (num7 == 0) ? left.Index.CompareTo(right.Index) : num7;
			});
			for (int num6 = 0; num6 < num5; num6++)
			{
				array[list[num6].Index]++;
			}
			return array;
		}
	}
	[BepInPlugin("com.tactikot.StaminaStatsTactikot", "StaminaStatsTactikot", "1.1.0")]
	[BepInProcess("PEAK.exe")]
	[BepInIncompatibility("com.StaminaStats")]
	public sealed class Plugin : BaseUnityPlugin
	{
		[HarmonyPatch(typeof(StaminaBar), "Start")]
		private static class StaminaBarStartPatch
		{
			private static void Postfix(StaminaBar __instance)
			{
				try
				{
					HudController.AttachTo(__instance);
				}
				catch (Exception exception)
				{
					ReportOnce("StaminaBar.Start patch failed", exception);
				}
			}
		}

		[HarmonyPatch(typeof(StaminaBar), "Update")]
		private static class StaminaBarUpdatePatch
		{
			private static void Postfix(StaminaBar __instance)
			{
				try
				{
					HudController.UpdateStamina(__instance);
				}
				catch (Exception exception)
				{
					ReportOnce("StaminaBar.Update patch failed", exception);
				}
			}
		}

		[HarmonyPatch(typeof(StaminaBar), "ChangeBar")]
		private static class StaminaBarChangePatch
		{
			private static void Postfix(StaminaBar __instance)
			{
				try
				{
					HudController.RefreshAfflictions(__instance);
				}
				catch (Exception exception)
				{
					ReportOnce("StaminaBar.ChangeBar patch failed", exception);
				}
			}
		}

		[HarmonyPatch(typeof(BarAffliction), "UpdateAffliction")]
		private static class BarAfflictionUpdatePatch
		{
			private static void Postfix(BarAffliction __instance, StaminaBar bar)
			{
				try
				{
					HudController.UpdateAffliction(__instance, bar);
				}
				catch (Exception exception)
				{
					ReportOnce("BarAffliction.UpdateAffliction patch failed", exception);
				}
			}
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static LogCallback <0>__OnUnityLogMessage;
		}

		public const string PluginGuid = "com.tactikot.StaminaStatsTactikot";

		public const string PluginName = "StaminaStatsTactikot";

		public const string PluginVersion = "1.1.0";

		private static readonly HashSet<string> ReportedErrors = new HashSet<string>();

		private Harmony harmony;

		internal static ManualLogSource Log { get; private set; }

		internal static ConfigEntry<bool> ShowPercentageSign { get; private set; }

		internal static ConfigEntry<int> StaminaFontSize { get; private set; }

		internal static ConfigEntry<int> AfflictionFontSize { get; private set; }

		internal static ConfigEntry<float> TextOutlineThickness { get; private set; }

		internal static ConfigEntry<bool> VerboseLogging { get; private set; }

		private void Awake()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			BindConfig();
			harmony = new Harmony("com.tactikot.StaminaStatsTactikot");
			harmony.PatchAll();
			object obj = <>O.<0>__OnUnityLogMessage;
			if (obj == null)
			{
				LogCallback val = OnUnityLogMessage;
				<>O.<0>__OnUnityLogMessage = val;
				obj = (object)val;
			}
			Application.logMessageReceived += (LogCallback)obj;
			Log.LogInfo((object)"StaminaStatsTactikot v1.1.0 loaded.");
		}

		private void OnDestroy()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			object obj = <>O.<0>__OnUnityLogMessage;
			if (obj == null)
			{
				LogCallback val = OnUnityLogMessage;
				<>O.<0>__OnUnityLogMessage = val;
				obj = (object)val;
			}
			Application.logMessageReceived -= (LogCallback)obj;
			Harmony obj2 = harmony;
			if (obj2 != null)
			{
				obj2.UnpatchSelf();
			}
			HudController.Cleanup();
		}

		private void BindConfig()
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Expected O, but got Unknown
			ShowPercentageSign = ((BaseUnityPlugin)this).Config.Bind<bool>("Display", "ShowPercentageSign", false, "Whether to show a percentage sign (%) after numeric values.");
			StaminaFontSize = ((BaseUnityPlugin)this).Config.Bind<int>("Display", "StaminaFontSize", 18, new ConfigDescription("Font size for stamina text display.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(10, 32), Array.Empty<object>()));
			AfflictionFontSize = ((BaseUnityPlugin)this).Config.Bind<int>("Display", "AfflictionFontSize", 16, new ConfigDescription("Font size for affliction text display.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(10, 32), Array.Empty<object>()));
			TextOutlineThickness = ((BaseUnityPlugin)this).Config.Bind<float>("Display", "TextOutlineThickness", 0.1f, new ConfigDescription("Thickness of the text outline.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 0.3f), Array.Empty<object>()));
			VerboseLogging = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "VerboseLogging", false, "Enable detailed diagnostic logging.");
		}

		private static void OnUnityLogMessage(string message, string stackTrace, LogType type)
		{
			if (message.Contains("RUN STARTED"))
			{
				HudController.ResetForNewRun();
			}
		}

		internal static void ReportOnce(string operation, Exception exception)
		{
			string item = operation + ":" + exception.GetType().FullName + ":" + exception.Message;
			if (ReportedErrors.Add(item))
			{
				Log.LogError((object)(operation + ": " + exception.Message));
				if (VerboseLogging.Value)
				{
					Log.LogError((object)exception);
				}
			}
		}
	}
}