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 BepInEx.Logging;
using HarmonyLib;
using UnityEngine;
using UnityEngine.Networking;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("PSOFOSDeath")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("PSOFOSDeath")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("e1c6268f-b8b6-49c2-b44e-6adbecdd155f")]
[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")]
[BepInPlugin("com.yourname.psofosdeath", "PSOFOS Death Overlay", "3.6.1")]
public class PSOFOSDeath : BaseUnityPlugin
{
	public class DeathHeartbeat : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <Tick>d__3 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public DeathHeartbeat <>4__this;

			private WaitForSeconds <wait>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Expected O, but got Unknown
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Expected O, but got Unknown
				int num = <>1__state;
				DeathHeartbeat deathHeartbeat = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<wait>5__2 = new WaitForSeconds(0.25f);
					<>2__current = (object)new WaitForSeconds(1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				bool flag = false;
				try
				{
					flag = deathHeartbeat.DetectDeadByReflection();
				}
				catch
				{
				}
				if (flag && !deathHeartbeat._lastDead)
				{
					deathHeartbeat._overlay?.PlayOneShotIfReady();
				}
				deathHeartbeat._lastDead = flag;
				<>2__current = <wait>5__2;
				<>1__state = 2;
				return true;
			}

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

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

		private DeathOverlay _overlay;

		private bool _lastDead;

		public void Init(DeathOverlay overlay)
		{
			_overlay = overlay;
			((MonoBehaviour)this).StartCoroutine(Tick());
		}

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

		private bool DetectDeadByReflection()
		{
			MonoBehaviour[] array = Object.FindObjectsOfType<MonoBehaviour>();
			foreach (MonoBehaviour val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Type type = ((object)val).GetType();
				string name = type.Name;
				if (name.IndexOf("PlayerAvatar", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("StatsManager", StringComparison.OrdinalIgnoreCase) < 0)
				{
					continue;
				}
				FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				foreach (FieldInfo fieldInfo in fields)
				{
					string text = fieldInfo.Name.ToLowerInvariant();
					if ((text == "isdead" || text == "dead") && fieldInfo.FieldType == typeof(bool))
					{
						try
						{
							if ((bool)fieldInfo.GetValue(val))
							{
								return true;
							}
						}
						catch
						{
						}
					}
					if (text.Contains("health") && (fieldInfo.FieldType == typeof(int) || fieldInfo.FieldType == typeof(float)))
					{
						try
						{
							if (Convert.ToSingle(fieldInfo.GetValue(val)) <= 0f)
							{
								return true;
							}
						}
						catch
						{
						}
					}
					if (!(text == "isdisabled") || !(fieldInfo.FieldType == typeof(bool)))
					{
						continue;
					}
					try
					{
						if ((bool)fieldInfo.GetValue(val))
						{
							return true;
						}
					}
					catch
					{
					}
				}
				PropertyInfo[] properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				foreach (PropertyInfo propertyInfo in properties)
				{
					if (!propertyInfo.CanRead)
					{
						continue;
					}
					string text2 = propertyInfo.Name.ToLowerInvariant();
					if ((!(text2 == "isdead") && !(text2 == "dead")) || !(propertyInfo.PropertyType == typeof(bool)))
					{
						continue;
					}
					try
					{
						if ((bool)propertyInfo.GetValue(val, null))
						{
							return true;
						}
					}
					catch
					{
					}
				}
			}
			return false;
		}
	}

	public class DeathOverlay : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <EnsureListenerAfterDelay>d__7 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public DeathOverlay <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Expected O, but got Unknown
				int num = <>1__state;
				DeathOverlay deathOverlay = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(1f);
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					bool flag = false;
					AudioListener[] array = Object.FindObjectsOfType<AudioListener>();
					foreach (AudioListener val in array)
					{
						if ((Object)(object)val != (Object)null && ((Behaviour)val).enabled)
						{
							flag = true;
							break;
						}
					}
					if (!flag)
					{
						deathOverlay._busGO.AddComponent<AudioListener>();
						ManualLogSource log = Log;
						if (log != null)
						{
							log.LogWarning((object)"[PSOFOS] No enabled AudioListener detected after delay; attached a temporary fallback listener.");
						}
					}
					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 <LoadClips>d__8 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public DeathOverlay <>4__this;

			private string[] <names>5__2;

			private int <i>5__3;

			private string <name>5__4;

			private UnityWebRequest <req>5__5;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<names>5__2 = null;
				<name>5__4 = null;
				<req>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					DeathOverlay deathOverlay = <>4__this;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -3;
						if (<req>5__5.isNetworkError || <req>5__5.isHttpError)
						{
							Debug.LogWarning((object)("[PSOFOS] Failed to load " + <name>5__4 + ": " + <req>5__5.error));
						}
						else
						{
							AudioClip content = DownloadHandlerAudioClip.GetContent(<req>5__5);
							if (!((Object)(object)content == (Object)null))
							{
								((Object)content).name = <name>5__4;
								deathOverlay._clips.Add(content);
								Debug.Log((object)("[PSOFOS] Loaded " + <name>5__4));
								<>m__Finally1();
								<req>5__5 = null;
								<name>5__4 = null;
								goto IL_018d;
							}
							Debug.LogWarning((object)("[PSOFOS] Loaded null clip for " + <name>5__4));
						}
						<>m__Finally1();
						goto IL_018d;
					}
					<>1__state = -1;
					<names>5__2 = new string[3] { "PSOFOS01.ogg", "PSOFOS02.ogg", "PSOFOS03.ogg" };
					<i>5__3 = 0;
					goto IL_019f;
					IL_019f:
					if (<i>5__3 < <names>5__2.Length)
					{
						<name>5__4 = <names>5__2[<i>5__3];
						string text = Path.Combine(deathOverlay._pluginDir, <name>5__4);
						if (File.Exists(text))
						{
							string absoluteUri = new Uri(text).AbsoluteUri;
							<req>5__5 = UnityWebRequestMultimedia.GetAudioClip(absoluteUri, (AudioType)14);
							<>1__state = -3;
							<>2__current = <req>5__5.SendWebRequest();
							<>1__state = 1;
							return true;
						}
						goto IL_018d;
					}
					if (deathOverlay._clips.Count == 0)
					{
						Debug.LogWarning((object)("[PSOFOS] No OGGs found. Expected next to DLL at: " + deathOverlay._pluginDir));
					}
					return false;
					IL_018d:
					<i>5__3++;
					goto IL_019f;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<req>5__5 != null)
				{
					((IDisposable)<req>5__5).Dispose();
				}
			}

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

		private readonly List<AudioClip> _clips = new List<AudioClip>();

		private AudioSource _bus;

		private GameObject _busGO;

		private string _pluginDir;

		private float _cooldownUntil;

		public void Init()
		{
			string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
			_pluginDir = (string.IsNullOrEmpty(directoryName) ? Path.Combine(Paths.PluginPath, "PSOFOSDeath") : directoryName);
			try
			{
				Directory.CreateDirectory(_pluginDir);
			}
			catch
			{
			}
			EnsureBus();
			((MonoBehaviour)this).StartCoroutine(LoadClips());
		}

		private void EnsureBus()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			if (!((Object)(object)_bus != (Object)null))
			{
				_busGO = new GameObject("PSOFOS_AudioBus");
				((Object)_busGO).hideFlags = (HideFlags)52;
				Object.DontDestroyOnLoad((Object)(object)_busGO);
				_bus = _busGO.AddComponent<AudioSource>();
				_bus.playOnAwake = false;
				_bus.spatialBlend = 0f;
				_bus.priority = 0;
				_bus.volume = 1.35f;
				_bus.bypassReverbZones = true;
				_bus.bypassEffects = true;
				_bus.bypassListenerEffects = true;
				_bus.dopplerLevel = 0f;
				_bus.reverbZoneMix = 0f;
				((MonoBehaviour)this).StartCoroutine(EnsureListenerAfterDelay());
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogInfo((object)"[PSOFOS] Created PSOFOS audio bus.");
				}
			}
		}

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

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

		public void PlayOneShotIfReady()
		{
			if (Time.unscaledTime < _cooldownUntil || _clips.Count == 0)
			{
				return;
			}
			EnsureBus();
			if ((Object)(object)_bus == (Object)null)
			{
				return;
			}
			AudioClip val = _clips[Random.Range(0, _clips.Count)];
			try
			{
				if (((Behaviour)_bus).isActiveAndEnabled && ((Component)_bus).gameObject.activeInHierarchy)
				{
					_bus.PlayOneShot(val, 1f);
					_cooldownUntil = Time.unscaledTime + 1f;
					ManualLogSource log = Log;
					if (log != null)
					{
						log.LogInfo((object)("[PSOFOS] Death event -> played '" + ((Object)val).name + "'."));
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log2 = Log;
				if (log2 != null)
				{
					log2.LogWarning((object)("[PSOFOS] OneShot play failed: " + ex));
				}
			}
		}
	}

	internal static ManualLogSource Log;

	private Harmony _harmony;

	private static DeathOverlay _overlay;

	private void Awake()
	{
		//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
		//IL_001b: 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_0040: Expected O, but got Unknown
		Log = ((BaseUnityPlugin)this).Logger;
		GameObject val = new GameObject("PSOFOS_DeathOverlay");
		Object.DontDestroyOnLoad((Object)val);
		_overlay = val.AddComponent<DeathOverlay>();
		_overlay.Init();
		_harmony = new Harmony("com.yourname.psofosdeath.harmony");
		Type type = AccessTools.TypeByName("PlayerAvatar");
		TryPatchPostfix(type, "PlayerDeath", "OnDeathPostfix");
		TryPatchPostfix(type, "PlayerDeathRPC", "OnDeathPostfix");
		TryPatchPostfix(type, "PlayerDeathDone", "OnDeathPostfix");
		val.AddComponent<DeathHeartbeat>().Init(_overlay);
		Log.LogInfo((object)"[PSOFOS] v3.6.1 initialized (3.2 hooks + edge-detected watcher)");
	}

	private void TryPatchPostfix(Type type, string method, string handlerName)
	{
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_009f: Expected O, but got Unknown
		if (type == null)
		{
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogWarning((object)("[PSOFOS] Type not found for method: " + method));
			}
			return;
		}
		MethodInfo methodInfo = AccessTools.Method(type, method, (Type[])null, (Type[])null);
		if (methodInfo == null)
		{
			ManualLogSource log2 = Log;
			if (log2 != null)
			{
				log2.LogWarning((object)("[PSOFOS] Method not found: " + ((type != null) ? type.Name : "null") + "." + method + "()"));
			}
			return;
		}
		HarmonyMethod val = new HarmonyMethod(typeof(PSOFOSDeath).GetMethod(handlerName, BindingFlags.Static | BindingFlags.NonPublic));
		_harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		ManualLogSource log3 = Log;
		if (log3 != null)
		{
			log3.LogInfo((object)("[PSOFOS] Patched " + type.Name + "." + method + "()"));
		}
	}

	private static void OnDeathPostfix()
	{
		try
		{
			_overlay?.PlayOneShotIfReady();
		}
		catch (Exception ex)
		{
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogWarning((object)("[PSOFOS] DeathPostfix error: " + ex));
			}
		}
	}

	private void OnDestroy()
	{
		try
		{
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}
		catch
		{
		}
	}
}