using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ArceDev.NativeStatusUI")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.2.1.0")]
[assembly: AssemblyInformationalVersion("0.2.1")]
[assembly: AssemblyProduct("ArceDev.NativeStatusUI")]
[assembly: AssemblyTitle("NativeStatusUI")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.2.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[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 BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	[Embedded]
	internal sealed class BepInAutoPluginAttribute : Attribute
	{
		public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace BepInEx.Preloader.Core.Patching
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	[Embedded]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace NativeStatusUI
{
	public static class NativeStatus
	{
		private static readonly Dictionary<string, StatusDefinition> Definitions = new Dictionary<string, StatusDefinition>(StringComparer.Ordinal);

		private static readonly List<string> Order = new List<string>();

		private static NativeStatusHost? _host;

		public static void Register(string id, byte[] png, Color color)
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrWhiteSpace(id))
			{
				throw new ArgumentException("A status identifier is required.", "id");
			}
			if (png == null || png.Length == 0)
			{
				throw new ArgumentException("A PNG mask is required.", "png");
			}
			if (Definitions.ContainsKey(id))
			{
				throw new InvalidOperationException("Native status '" + id + "' is already registered.");
			}
			StatusDefinition statusDefinition = new StatusDefinition(id, (byte[])png.Clone(), color);
			Definitions.Add(id, statusDefinition);
			Order.Add(id);
			_host?.Add(statusDefinition);
		}

		public static void Activate(string id, float durationSeconds)
		{
			if (!Definitions.TryGetValue(id, out StatusDefinition value))
			{
				throw new KeyNotFoundException("Native status '" + id + "' is not registered.");
			}
			if (durationSeconds <= 0f)
			{
				throw new ArgumentOutOfRangeException("durationSeconds", "Duration must be positive.");
			}
			value.Duration = durationSeconds;
			value.ExpiresAt = Time.time + durationSeconds;
		}

		public static void Hide(string id)
		{
			if (Definitions.TryGetValue(id, out StatusDefinition value))
			{
				value.Duration = 0f;
				value.ExpiresAt = 0f;
			}
		}

		internal static void Attach(CanvasGroup poisonGroup, CanvasGroup fireGroup, Image fireImage, Image firePercent, Image firePercentLerped)
		{
			NativeStatusHost nativeStatusHost = ((Component)fireGroup).gameObject.AddComponent<NativeStatusHost>();
			nativeStatusHost.Initialize(poisonGroup, fireGroup, fireImage, firePercent, firePercentLerped);
			_host = nativeStatusHost;
			foreach (string item in Order)
			{
				nativeStatusHost.Add(Definitions[item]);
			}
		}

		internal static float GetPercent(StatusDefinition definition, float now)
		{
			return CalculatePercent(definition.Duration, definition.ExpiresAt, now);
		}

		internal static void Detach(NativeStatusHost host)
		{
			if ((Object)(object)_host == (Object)(object)host)
			{
				_host = null;
			}
		}

		internal static void Validate()
		{
			if (CalculatePercent(60f, 60f, 30f) != 0.5f || CalculatePercent(0f, 60f, 30f) != 0f || CalculatePercent(60f, 30f, 60f) != 0f)
			{
				throw new InvalidOperationException("NativeStatusUI duration validation failed.");
			}
		}

		private static float CalculatePercent(float duration, float expiresAt, float now)
		{
			if (!(duration > 0f))
			{
				return 0f;
			}
			return Mathf.Clamp01((expiresAt - now) / duration);
		}
	}
	internal sealed class StatusDefinition
	{
		internal string Id { get; }

		internal byte[] Png { get; }

		internal Color Color { get; }

		internal float Duration { get; set; }

		internal float ExpiresAt { get; set; }

		internal StatusDefinition(string id, byte[] png, Color color)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			Id = id;
			Png = png;
			Color = color;
		}
	}
	internal sealed class NativeStatusHost : MonoBehaviour
	{
		private readonly List<StatusView> _views = new List<StatusView>();

		private CanvasGroup _fireGroup;

		private Image _fireImage;

		private Image _firePercent;

		private Image _firePercentLerped;

		private RectTransform _fireRect;

		private Vector2 _spacing;

		internal void Initialize(CanvasGroup poisonGroup, CanvasGroup fireGroup, Image fireImage, Image firePercent, Image firePercentLerped)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_0042: 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_004d: 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)
			_fireGroup = fireGroup;
			_fireImage = fireImage;
			_firePercent = firePercent;
			_firePercentLerped = firePercentLerped;
			RectTransform val = (RectTransform)((Component)poisonGroup).transform;
			_fireRect = (RectTransform)((Component)fireGroup).transform;
			_spacing = _fireRect.anchoredPosition - val.anchoredPosition;
		}

		internal void Add(StatusDefinition definition)
		{
			_views.Add(StatusView.Create(definition, _fireGroup, _fireImage, _firePercent, _firePercentLerped));
		}

		private void Update()
		{
			//IL_003e: 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)
			//IL_004f: 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)
			float time = Time.time;
			int num = 0;
			foreach (StatusView view in _views)
			{
				if (view.SetPercent(NativeStatus.GetPercent(view.Definition, time)))
				{
					view.Rect.anchoredPosition = _fireRect.anchoredPosition + _spacing * (float)(++num);
				}
			}
		}

		private void OnDestroy()
		{
			NativeStatus.Detach(this);
			foreach (StatusView view in _views)
			{
				view.Dispose();
			}
		}
	}
	internal sealed class StatusView : IDisposable
	{
		private readonly GameObject _root;

		private readonly CanvasGroup _group;

		private readonly Image _percent;

		private readonly Image _percentLerped;

		private readonly Sprite _sprite;

		private readonly Texture2D _texture;

		internal StatusDefinition Definition { get; }

		internal RectTransform Rect { get; }

		private StatusView(StatusDefinition definition, GameObject root, CanvasGroup group, Image percent, Image percentLerped, Sprite sprite, Texture2D texture)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			Definition = definition;
			_root = root;
			_group = group;
			_percent = percent;
			_percentLerped = percentLerped;
			_sprite = sprite;
			_texture = texture;
			Rect = (RectTransform)root.transform;
		}

		internal static StatusView Create(StatusDefinition definition, CanvasGroup fireGroup, Image fireImage, Image firePercent, Image firePercentLerped)
		{
			//IL_0055: 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_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(((Component)fireGroup).gameObject, ((Component)fireGroup).transform.parent);
			((Object)val).name = definition.Id;
			Image[] componentsInChildren = ((Component)fireGroup).GetComponentsInChildren<Image>(true);
			Image[] componentsInChildren2 = val.GetComponentsInChildren<Image>(true);
			Image val2 = FindClone(fireImage, componentsInChildren, componentsInChildren2);
			Image val3 = FindClone(firePercent, componentsInChildren, componentsInChildren2);
			Image val4 = FindClone(firePercentLerped, componentsInChildren, componentsInChildren2);
			Texture2D val5 = new Texture2D(2, 2, (TextureFormat)4, false)
			{
				name = definition.Id,
				wrapMode = (TextureWrapMode)1
			};
			if (!ImageConversion.LoadImage(val5, definition.Png, true))
			{
				Object.Destroy((Object)(object)val);
				Object.Destroy((Object)(object)val5);
				throw new InvalidOperationException("Native status '" + definition.Id + "' does not contain a valid PNG.");
			}
			Sprite sprite = (val2.sprite = Sprite.Create(val5, new Rect(0f, 0f, (float)((Texture)val5).width, (float)((Texture)val5).height), new Vector2(0.5f, 0.5f), 100f));
			((Graphic)val2).material = ((Graphic)fireImage).material;
			((Graphic)val2).color = definition.Color;
			val2.preserveAspect = true;
			((Graphic)val3).color = definition.Color;
			((Graphic)val4).color = definition.Color;
			CanvasGroup component = val.GetComponent<CanvasGroup>();
			component.alpha = 0f;
			return new StatusView(definition, val, component, val3, val4, sprite, val5);
		}

		internal bool SetPercent(float percent)
		{
			bool flag = percent > 0f;
			_group.alpha = (flag ? 1f : 0f);
			_percent.fillAmount = percent;
			_percentLerped.fillAmount = percent;
			return flag;
		}

		public void Dispose()
		{
			if (Object.op_Implicit((Object)(object)_root))
			{
				Object.Destroy((Object)(object)_root);
			}
			Object.Destroy((Object)(object)_sprite);
			Object.Destroy((Object)(object)_texture);
		}

		private static Image FindClone(Image source, Image[] sourceImages, Image[] clonedImages)
		{
			int num = Array.IndexOf(sourceImages, source);
			if (num < 0 || num >= clonedImages.Length)
			{
				throw new InvalidOperationException("The native vitals UI hierarchy has changed.");
			}
			return clonedImages[num];
		}
	}
	[BepInPlugin("ArceDev.NativeStatusUI", "NativeStatusUI", "0.2.1")]
	public class Plugin : BaseUnityPlugin
	{
		[HarmonyPatch(typeof(VitalsUI), "Awake")]
		private static class VitalsUiPatch
		{
			private static void Postfix(CanvasGroup ____poisonGroup, CanvasGroup ____fireGroup, Image ____fireImage, Image ____firePercent, Image ____firePercentLerped)
			{
				NativeStatus.Attach(____poisonGroup, ____fireGroup, ____fireImage, ____firePercent, ____firePercentLerped);
			}
		}

		public const string Id = "ArceDev.NativeStatusUI";

		internal static ManualLogSource Log { get; private set; }

		public static string Name => "NativeStatusUI";

		public static string Version => "0.2.1";

		private void Awake()
		{
			Log = ((BaseUnityPlugin)this).Logger;
			NativeStatus.Validate();
			Harmony.CreateAndPatchAll(typeof(Plugin).Assembly, "ArceDev.NativeStatusUI");
			Log.LogInfo((object)("Plugin " + Name + " is loaded!"));
		}
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ConstantExpectedAttribute : Attribute
	{
		public object? Min { get; set; }

		public object? Max { get; set; }
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ExperimentalAttribute : Attribute
	{
		public string DiagnosticId { get; }

		public string? UrlFormat { get; set; }

		public ExperimentalAttribute(string diagnosticId)
		{
			DiagnosticId = diagnosticId;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	internal sealed class MemberNotNullAttribute : Attribute
	{
		public string[] Members { get; }

		public MemberNotNullAttribute(string member)
		{
			Members = new string[1] { member };
		}

		public MemberNotNullAttribute(params string[] members)
		{
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	internal sealed class MemberNotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public string[] Members { get; }

		public MemberNotNullWhenAttribute(bool returnValue, string member)
		{
			ReturnValue = returnValue;
			Members = new string[1] { member };
		}

		public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
		{
			ReturnValue = returnValue;
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class SetsRequiredMembersAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class StringSyntaxAttribute : Attribute
	{
		public const string CompositeFormat = "CompositeFormat";

		public const string DateOnlyFormat = "DateOnlyFormat";

		public const string DateTimeFormat = "DateTimeFormat";

		public const string EnumFormat = "EnumFormat";

		public const string GuidFormat = "GuidFormat";

		public const string Json = "Json";

		public const string NumericFormat = "NumericFormat";

		public const string Regex = "Regex";

		public const string TimeOnlyFormat = "TimeOnlyFormat";

		public const string TimeSpanFormat = "TimeSpanFormat";

		public const string Uri = "Uri";

		public const string Xml = "Xml";

		public string Syntax { get; }

		public object?[] Arguments { get; }

		public StringSyntaxAttribute(string syntax)
		{
			Syntax = syntax;
			Arguments = new object[0];
		}

		public StringSyntaxAttribute(string syntax, params object?[] arguments)
		{
			Syntax = syntax;
			Arguments = arguments;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class UnscopedRefAttribute : Attribute
	{
	}
}
namespace System.Runtime.Versioning
{
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class RequiresPreviewFeaturesAttribute : Attribute
	{
		public string? Message { get; }

		public string? Url { get; set; }

		public RequiresPreviewFeaturesAttribute()
		{
		}

		public RequiresPreviewFeaturesAttribute(string? message)
		{
			Message = message;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CallerArgumentExpressionAttribute : Attribute
	{
		public string ParameterName { get; }

		public CallerArgumentExpressionAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CollectionBuilderAttribute : Attribute
	{
		public Type BuilderType { get; }

		public string MethodName { get; }

		public CollectionBuilderAttribute(Type builderType, string methodName)
		{
			BuilderType = builderType;
			MethodName = methodName;
		}
	}
	[AttributeUsage(AttributeTargets.All, AllowMultiple = true, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CompilerFeatureRequiredAttribute : Attribute
	{
		public const string RefStructs = "RefStructs";

		public const string RequiredMembers = "RequiredMembers";

		public string FeatureName { get; }

		public bool IsOptional { get; set; }

		public CompilerFeatureRequiredAttribute(string featureName)
		{
			FeatureName = featureName;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class InterpolatedStringHandlerArgumentAttribute : Attribute
	{
		public string[] Arguments { get; }

		public InterpolatedStringHandlerArgumentAttribute(string argument)
		{
			Arguments = new string[1] { argument };
		}

		public InterpolatedStringHandlerArgumentAttribute(params string[] arguments)
		{
			Arguments = arguments;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class InterpolatedStringHandlerAttribute : Attribute
	{
	}
	[EditorBrowsable(EditorBrowsableState.Never)]
	[ExcludeFromCodeCoverage]
	internal static class IsExternalInit
	{
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ModuleInitializerAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class OverloadResolutionPriorityAttribute : Attribute
	{
		public int Priority { get; }

		public OverloadResolutionPriorityAttribute(int priority)
		{
			Priority = priority;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = true, AllowMultiple = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ParamCollectionAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class RequiredMemberAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[EditorBrowsable(EditorBrowsableState.Never)]
	[ExcludeFromCodeCoverage]
	internal sealed class RequiresLocationAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Event | AttributeTargets.Interface, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class SkipLocalsInitAttribute : Attribute
	{
	}
}