using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using Microsoft.CodeAnalysis;
using PEAKLib.Core;
using PEAKLib.Items.UnityEditor;
using PEAKLib.Stats;
using UnityEngine;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("FirstAid")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("FirstAid")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("D5DF341F-804A-43C0-86C9-D3B2F89589B9")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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]
	[Microsoft.CodeAnalysis.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;
		}
	}
}
public class Action_PainKillers : ItemAction
{
	public FirstAid firstAidHost;

	public override void RunAction()
	{
		if (Object.op_Implicit((Object)(object)((ItemActionBase)this).character))
		{
			if (Random.Range(1, 100) == 5)
			{
				((MonoBehaviour)((ItemActionBase)this).character).Invoke("DieInstantly", 0.02f);
			}
			else if (firstAidHost.PainKillersOn < 3)
			{
				firstAidHost.PainKillerEffects(((ItemActionBase)this).character.refs.afflictions);
			}
			else
			{
				firstAidHost.Overdose(((ItemActionBase)this).character.refs.afflictions);
			}
		}
	}
}
public static class FirstAidAfflictions
{
	public static STATUSTYPE Overdose;

	public static STATUSTYPE Bacteria;

	public static void RegisterAfflictions()
	{
		//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_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: 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_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: 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_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_006f: Expected O, but got Unknown
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		//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_0094: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00db: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f3: Expected O, but got Unknown
		//IL_00ee: 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_0103: Unknown result type (might be due to invalid IL or missing references)
		Sprite icon = SpriteLoader.FromEmbedded("FirstAid.Sprites.pill.png");
		Status val = new Status
		{
			Name = "Overdose",
			Color = new Color(0.48f, 1f, 0.196f),
			MaxAmount = 2f,
			AllowClear = true,
			ReductionCooldown = 0f,
			ReductionPerSecond = 0f,
			Icon = icon
		};
		new StatusContent(val).Register(FirstAid.Definition);
		Overdose = val.Type;
		SpriteLoader.FromEmbedded("FirstAid.Sprites.bacteria.png");
		Status val2 = new Status
		{
			Name = "Bacteria",
			Color = new Color(1f, 0.576f, 0.196f),
			MaxAmount = 2f,
			AllowClear = true,
			ReductionCooldown = 0f,
			ReductionPerSecond = -0.1f,
			Icon = icon
		};
		new StatusContent(val2).Register(FirstAid.Definition);
		Bacteria = val2.Type;
	}
}
[BepInPlugin("com.khakixd.firstaid", "FirstAid", "0.1.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class FirstAid : BaseUnityPlugin
{
	[CompilerGenerated]
	private sealed class <OverdosePlayer>d__15 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public CharacterAfflictions afflicts;

		private float <x>5__2;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <OverdosePlayer>d__15(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_005d: 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)
			//IL_002f: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<x>5__2 = 0f;
				break;
			case 1:
				<>1__state = -1;
				<x>5__2 += Time.deltaTime * 0.05f;
				afflicts.AddStatus(FirstAidAfflictions.Overdose, Time.deltaTime * 0.05f, false);
				break;
			}
			if (<x>5__2 < 2f)
			{
				<>2__current = (object)new WaitForEndOfFrame();
				<>1__state = 1;
				return true;
			}
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <PainKillerCoroutine>d__17 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public FirstAid <>4__this;

		public CharacterAfflictions afflicts;

		private float[] <removedPhase1>5__2;

		private float[] <suppressedPhase2>5__3;

		private float <suppressTimer>5__4;

		private float[] <remaining>5__5;

		private float <restoreTimer>5__6;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <PainKillerCoroutine>d__17(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<removedPhase1>5__2 = null;
			<suppressedPhase2>5__3 = null;
			<remaining>5__5 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_008d: 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_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: 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)
			int num = <>1__state;
			FirstAid firstAid = <>4__this;
			float num4;
			switch (num)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				firstAid.PainKillersOn++;
				<removedPhase1>5__2 = new float[PainKillerAfflictions.Length];
				<suppressedPhase2>5__3 = new float[PainKillerAfflictions.Length];
				goto IL_005f;
			case 1:
			{
				<>1__state = -1;
				bool flag2 = false;
				for (int l = 0; l < PainKillerAfflictions.Length; l++)
				{
					STATUSTYPE val2 = PainKillerAfflictions[l];
					float currentStatus5 = afflicts.GetCurrentStatus(val2);
					if (currentStatus5 > 0.001f)
					{
						float num6 = 0.05f * Time.deltaTime;
						num6 = Mathf.Min(num6, currentStatus5);
						afflicts.SubtractStatus(val2, num6, false);
						float currentStatus6 = afflicts.GetCurrentStatus(val2);
						float num7 = Mathf.Max(0f, currentStatus5 - currentStatus6);
						if (num7 > 0f)
						{
							<removedPhase1>5__2[l] += num7;
						}
						if (currentStatus6 > 0.001f)
						{
							flag2 = true;
						}
					}
				}
				if (flag2)
				{
					goto IL_005f;
				}
				<suppressTimer>5__4 = 0f;
				goto IL_01f2;
			}
			case 2:
			{
				<>1__state = -1;
				<suppressTimer>5__4 += Time.deltaTime;
				for (int k = 0; k < PainKillerAfflictions.Length; k++)
				{
					STATUSTYPE val = PainKillerAfflictions[k];
					float currentStatus3 = afflicts.GetCurrentStatus(val);
					if (currentStatus3 > 0.001f)
					{
						afflicts.SubtractStatus(val, currentStatus3, false);
						float currentStatus4 = afflicts.GetCurrentStatus(val);
						float num5 = Mathf.Max(0f, currentStatus3 - currentStatus4);
						if (num5 > 0f)
						{
							<suppressedPhase2>5__3[k] += num5;
						}
					}
				}
				goto IL_01f2;
			}
			case 3:
				{
					<>1__state = -1;
					<restoreTimer>5__6 += Time.deltaTime;
					bool flag = true;
					for (int i = 0; i < <remaining>5__5.Length; i++)
					{
						if (<remaining>5__5[i] > 0.001f)
						{
							flag = false;
							float num2 = Mathf.Min(0.01f * Time.deltaTime, <remaining>5__5[i]);
							float currentStatus = afflicts.GetCurrentStatus(PainKillerAfflictions[i]);
							afflicts.AddStatus(PainKillerAfflictions[i], num2, false);
							float currentStatus2 = afflicts.GetCurrentStatus(PainKillerAfflictions[i]);
							float num3 = Mathf.Max(0f, currentStatus2 - currentStatus);
							if (num3 > 0f)
							{
								<remaining>5__5[i] -= num3;
							}
						}
					}
					if (flag)
					{
						break;
					}
					if (<restoreTimer>5__6 > 180f)
					{
						Debug.LogWarning((object)"[FirstAid] Restore phase exceeded safety time; finishing early to avoid infinite loop.");
						break;
					}
					goto IL_0283;
				}
				IL_0283:
				<>2__current = firstAid._wfeof;
				<>1__state = 3;
				return true;
				IL_005f:
				<>2__current = firstAid._wfeof;
				<>1__state = 1;
				return true;
				IL_01f2:
				if (<suppressTimer>5__4 < 25f)
				{
					<>2__current = firstAid._wfeof;
					<>1__state = 2;
					return true;
				}
				<remaining>5__5 = new float[PainKillerAfflictions.Length];
				num4 = 0f;
				for (int j = 0; j < <remaining>5__5.Length; j++)
				{
					<remaining>5__5[j] = <removedPhase1>5__2[j] + <suppressedPhase2>5__3[j];
					num4 += <remaining>5__5[j];
				}
				if (num4 <= 0.001f)
				{
					firstAid.PainKillersOn--;
					firstAid._painKillerRoutine = null;
					return false;
				}
				<restoreTimer>5__6 = 0f;
				goto IL_0283;
			}
			firstAid.PainKillersOn--;
			firstAid._painKillerRoutine = null;
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	public int PainKillersOn;

	private const float EPSILON = 0.001f;

	private const float LOWER_RATE_PER_SEC = 0.05f;

	private const float SUPPRESS_DURATION = 25f;

	private const float RESTORE_RATE_PER_SEC = 0.01f;

	private const float MAX_RESTORE_TIME = 180f;

	private Coroutine _painKillerRoutine;

	private readonly WaitForEndOfFrame _wfeof = new WaitForEndOfFrame();

	private static readonly STATUSTYPE[] PainKillerAfflictions;

	public static ModDefinition Definition { get; set; } = null;


	public void Awake()
	{
		Definition = ModDefinition.GetOrCreate(((BaseUnityPlugin)this).Info.Metadata);
		FirstAidAfflictions.RegisterAfflictions();
		Debug.Log((object)"FirstAid plugin is loaded!");
		BundleLoader.LoadBundleWithName((BaseUnityPlugin)(object)this, "firstaid.peakbundle", (Action<PeakBundle>)delegate(PeakBundle bundle)
		{
			Action_PainKillers action_PainKillers = bundle.LoadAsset<UnityItemContent>("Pills").ItemPrefab.AddComponent<Action_PainKillers>();
			action_PainKillers.firstAidHost = this;
			((ItemAction)action_PainKillers).OnCastFinished = true;
			bundle.Mod.RegisterContent();
		});
		PatchLocalization();
		SceneManager.sceneLoaded += delegate
		{
			if (_painKillerRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_painKillerRoutine);
				_painKillerRoutine = null;
			}
			PainKillersOn = 0;
		};
	}

	public void Overdose(CharacterAfflictions afflicts)
	{
		((MonoBehaviour)this).StartCoroutine(OverdosePlayer(afflicts));
	}

	[IteratorStateMachine(typeof(<OverdosePlayer>d__15))]
	private IEnumerator OverdosePlayer(CharacterAfflictions afflicts)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <OverdosePlayer>d__15(0)
		{
			afflicts = afflicts
		};
	}

	public void PainKillerEffects(CharacterAfflictions afflicts)
	{
		if (!((Object)(object)afflicts == (Object)null))
		{
			if (_painKillerRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_painKillerRoutine);
			}
			_painKillerRoutine = ((MonoBehaviour)this).StartCoroutine(PainKillerCoroutine(afflicts));
		}
	}

	[IteratorStateMachine(typeof(<PainKillerCoroutine>d__17))]
	private IEnumerator PainKillerCoroutine(CharacterAfflictions afflicts)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <PainKillerCoroutine>d__17(0)
		{
			<>4__this = this,
			afflicts = afflicts
		};
	}

	private void PatchLocalization()
	{
		LocalizedText.mainTable["NAME_PAIN KILLERS"] = new List<string> { "Pain Killers" };
		LocalizedText.mainTable["NAME_MELATONIN"] = new List<string> { "Melatonin" };
	}

	static FirstAid()
	{
		STATUSTYPE[] array = new STATUSTYPE[4];
		RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		PainKillerAfflictions = (STATUSTYPE[])(object)array;
	}
}
internal static class SpriteLoader
{
	public static Sprite FromEmbedded(string resourceName, float pixelsPerUnit = 100f)
	{
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Expected O, but got Unknown
		//IL_008b: 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)
		using Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(resourceName);
		if (stream == null)
		{
			Debug.LogError((object)("[FirstAid] Embedded resource not found: " + resourceName));
			return null;
		}
		using MemoryStream memoryStream = new MemoryStream();
		stream.CopyTo(memoryStream);
		Texture2D val = new Texture2D(2, 2, (TextureFormat)5, false);
		if (!ImageConversion.LoadImage(val, memoryStream.ToArray()))
		{
			Debug.LogError((object)("[FirstAid] Failed to load image data for: " + resourceName));
			return null;
		}
		((Object)val).name = Path.GetFileNameWithoutExtension(resourceName);
		((Texture)val).filterMode = (FilterMode)1;
		return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), pixelsPerUnit);
	}
}